gst_ape_demux_identify_tag (GstTagDemux * demux, GstBuffer * buffer,
gboolean start_tag, guint * tag_size)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- if (memcmp (data, "APETAGEX", 8) != 0) {
+ if (memcmp (map.data, "APETAGEX", 8) != 0) {
GST_DEBUG_OBJECT (demux, "No APETAGEX marker at %s - not an APE file",
(start_tag) ? "start" : "end");
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
- *tag_size = GST_READ_UINT32_LE (data + 12);
+ *tag_size = GST_READ_UINT32_LE (map.data + 12);
/* size is without header, so add 32 to account for that */
*tag_size += 32;
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return TRUE;
}
gst_ape_demux_parse_tag (GstTagDemux * demux, GstBuffer * buffer,
gboolean start_tag, guint * tag_size, GstTagList ** tags)
{
- guint8 *data_start, *data;
+ guint8 *data;
guint8 *footer;
gboolean have_header;
gboolean end_tag = !start_tag;
GstCaps *sink_caps;
guint version, footer_size;
+ GstMapInfo map;
gsize size;
- data_start = data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
GST_LOG_OBJECT (demux, "Parsing buffer of size %" G_GSIZE_FORMAT, size);
GST_TAG_CONTAINER_FORMAT, sink_caps);
gst_caps_unref (sink_caps);
- gst_buffer_unmap (buffer, data_start, size);
+ gst_buffer_unmap (buffer, &map);
return GST_TAG_DEMUX_RESULT_OK;
}
GstAudioAmplify *filter = GST_AUDIO_AMPLIFY (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)))
return GST_FLOW_OK;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (filter);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
- filter->process (filter, data, num_samples);
+ filter->process (filter, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
GstAudioDynamic *filter = GST_AUDIO_DYNAMIC (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)))
return GST_FLOW_OK;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (filter);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
- filter->process (filter, data, num_samples);
+ filter->process (filter, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
GstAudioEcho *self = GST_AUDIO_ECHO (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
}
}
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (self);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (self);
- self->process (self, data, num_samples);
+ self->process (self, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
gint channels = GST_AUDIO_FILTER_CHANNELS (self);
gint bps = GST_AUDIO_FILTER_BPS (self);
gint outsize, outsamples;
- guint8 *in, *out, *data;
- gsize size;
+ GstMapInfo map;
+ guint8 *in, *out;
if (channels == 0 || rate == 0 || self->nsamples_in == 0) {
self->buffer_fill = 0;
/* Convolve the residue with zeros to get the actual remaining data */
in = g_new0 (guint8, outsize);
- data = gst_buffer_map (outbuf, &size, NULL, GST_MAP_READWRITE);
- self->nsamples_out += self->process (self, in, data, outsamples);
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
+ self->nsamples_out += self->process (self, in, map.data, outsamples);
+ gst_buffer_unmap (outbuf, &map);
g_free (in);
} else {
guint gensamples = 0;
outbuf = gst_buffer_new_and_alloc (outsize);
- data = gst_buffer_map (outbuf, &size, NULL, GST_MAP_READWRITE);
+ gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
while (gensamples < outsamples) {
guint step_insamples = self->block_length - self->buffer_fill;
step_gensamples = self->process (self, zeroes, out, step_insamples);
g_free (zeroes);
- memcpy (data + gensamples * bps, out, MIN (step_gensamples,
+ memcpy (map.data + gensamples * bps, out, MIN (step_gensamples,
outsamples - gensamples) * bps);
gensamples += MIN (step_gensamples, outsamples - gensamples);
}
self->nsamples_out += gensamples;
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_unmap (outbuf, &map);
}
/* Set timestamp, offset, etc from the values we
gint channels = GST_AUDIO_FILTER_CHANNELS (self);
gint rate = GST_AUDIO_FILTER_RATE (self);
gint bps = GST_AUDIO_FILTER_BPS (self);
- guint8 *indata, *outdata;
- gsize insize, outsize;
+ GstMapInfo inmap, outmap;
guint input_samples;
guint output_samples;
guint generated_samples;
self->start_off = GST_BUFFER_OFFSET (inbuf);
}
- indata = gst_buffer_map (inbuf, &insize, NULL, GST_MAP_READ);
- outdata = gst_buffer_map (outbuf, &outsize, NULL, GST_MAP_WRITE);
+ gst_buffer_map (inbuf, &inmap, GST_MAP_READ);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
- input_samples = (insize / bps) / channels;
- output_samples = (outsize / bps) / channels;
+ input_samples = (inmap.size / bps) / channels;
+ output_samples = (outmap.size / bps) / channels;
self->nsamples_in += input_samples;
- generated_samples = self->process (self, indata, outdata, input_samples);
+ generated_samples =
+ self->process (self, inmap.data, outmap.data, input_samples);
- gst_buffer_unmap (inbuf, indata, insize);
- gst_buffer_unmap (outbuf, outdata, outsize);
+ gst_buffer_unmap (inbuf, &inmap);
+ gst_buffer_unmap (outbuf, &outmap);
g_assert (generated_samples <= output_samples);
self->nsamples_out += generated_samples;
GstAudioFXBaseIIRFilter *filter = GST_AUDIO_FX_BASE_IIR_FILTER (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
g_return_val_if_fail (filter->a != NULL, GST_FLOW_ERROR);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (filter);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
- filter->process (filter, data, num_samples);
+ filter->process (filter, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
GstAudioInvert *filter = GST_AUDIO_INVERT (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)))
return GST_FLOW_OK;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (filter);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
- filter->process (filter, data, num_samples);
+ filter->process (filter, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
GstAudioKaraoke *filter = GST_AUDIO_KARAOKE (base);
guint num_samples;
GstClockTime timestamp, stream_time;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
timestamp = GST_BUFFER_TIMESTAMP (buf);
stream_time =
G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)))
return GST_FLOW_OK;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- num_samples = size / GST_AUDIO_FILTER_BPS (filter);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
- filter->process (filter, data, num_samples);
+ filter->process (filter, map.data, num_samples);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
{
GstAudioPanorama *filter = GST_AUDIO_PANORAMA (base);
GstClockTime timestamp, stream_time;
- guint8 *indata, *outdata;
- gsize insize, outsize;
+ GstMapInfo inmap, outmap;
timestamp = GST_BUFFER_TIMESTAMP (inbuf);
stream_time =
if (GST_CLOCK_TIME_IS_VALID (stream_time))
gst_object_sync_values (GST_OBJECT (filter), stream_time);
- indata = gst_buffer_map (inbuf, &insize, NULL, GST_MAP_READ);
- outdata = gst_buffer_map (outbuf, &outsize, NULL, GST_MAP_WRITE);
+ gst_buffer_map (inbuf, &inmap, GST_MAP_READ);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_GAP))) {
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_GAP);
- memset (outdata, 0, outsize);
+ memset (outmap.data, 0, outmap.size);
} else {
- guint num_samples = outsize / GST_AUDIO_INFO_BPF (&filter->info);
+ guint num_samples = outmap.size / GST_AUDIO_INFO_BPF (&filter->info);
- filter->process (filter, indata, outdata, num_samples);
+ filter->process (filter, inmap.data, outmap.data, num_samples);
}
- gst_buffer_unmap (inbuf, indata, insize);
- gst_buffer_unmap (outbuf, outdata, outsize);
+ gst_buffer_unmap (inbuf, &inmap);
+ gst_buffer_unmap (outbuf, &outmap);
return GST_FLOW_OK;
}
GstBuffer *buf = gst_value_get_buffer (value);
if (buf) {
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint sr_idx;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- sr_idx = ((data[0] & 0x07) << 1) | ((data[1] & 0x80) >> 7);
- aacparse->object_type = (data[0] & 0xf8) >> 3;
+ sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
+ aacparse->object_type = (map.data[0] & 0xf8) >> 3;
aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
- aacparse->channels = (data[1] & 0x78) >> 3;
+ aacparse->channels = (map.data[1] & 0x78) >> 3;
aacparse->header_type = DSPAAC_HEADER_NONE;
aacparse->mpegversion = 4;
- aacparse->frame_samples = (data[1] & 4) ? 960 : 1024;
- gst_buffer_unmap (buf, data, size);
+ aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
+ gst_buffer_unmap (buf, &map);
GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
"samples=%d", aacparse->object_type, aacparse->sample_rate,
gst_aac_parse_check_valid_frame (GstBaseParse * parse,
GstBaseParseFrame * frame, guint * framesize, gint * skipsize)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
GstAacParse *aacparse;
gboolean ret = FALSE;
gboolean lost_sync;
aacparse = GST_AAC_PARSE (parse);
buffer = frame->buffer;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
aacparse->header_type == DSPAAC_HEADER_NONE) {
/* There is nothing to parse */
- *framesize = size;
+ *framesize = map.size;
ret = TRUE;
} else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
- ret = gst_aac_parse_detect_stream (aacparse, data, size,
+ ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
GST_BASE_PARSE_DRAINING (parse), framesize, skipsize);
} else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
guint needed_data = 1024;
- ret = gst_aac_parse_check_adts_frame (aacparse, data, size,
+ ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
if (!ret) {
} else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
guint needed_data = 1024;
- ret = gst_aac_parse_check_loas_frame (aacparse, data,
- size, GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
+ ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
+ map.size, GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
if (!ret) {
GST_DEBUG ("buffer didn't contain valid frame");
gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
ADTS_MAX_SIZE);
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
GstBuffer *buffer;
GstFlowReturn ret = GST_FLOW_OK;
gint rate, channels;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
aacparse = GST_AAC_PARSE (parse);
buffer = frame->buffer;
/* see above */
frame->overhead = 7;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- gst_aac_parse_parse_adts_header (aacparse, data,
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ gst_aac_parse_parse_adts_header (aacparse, map.data,
&rate, &channels, NULL, NULL);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
/* see above */
frame->overhead = 3;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- if (!gst_aac_parse_read_loas_config (aacparse, data, size, &rate, &channels,
- NULL)) {
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
+ &channels, NULL)) {
GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
} else if (G_UNLIKELY (rate != aacparse->sample_rate
|| channels != aacparse->channels)) {
GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
channels);
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
/* We want to set caps both at start, and when rate/channels change.
Since only some LOAS frames have that info, we may receive frames
guint * sid)
{
GstBitReader bits;
- gpointer data;
- gsize size;
+ GstMapInfo map;
guint8 fscod, frmsizcod, bsid, acmod, lfe_on, rate_scale;
gboolean ret = FALSE;
GST_LOG_OBJECT (ac3parse, "parsing ac3");
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- gst_bit_reader_init (&bits, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ gst_bit_reader_init (&bits, map.data, map.size);
gst_bit_reader_skip_unchecked (&bits, skip * 8);
gst_bit_reader_skip_unchecked (&bits, 16 + 16);
ret = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return ret;
}
guint * sid)
{
GstBitReader bits;
- gpointer data;
- gsize size;
+ GstMapInfo map;
guint16 frmsiz, sample_rate, blocks;
guint8 strmtyp, fscod, fscod2, acmod, lfe_on, strmid, numblkscod;
gboolean ret = FALSE;
GST_LOG_OBJECT (ac3parse, "parsing e-ac3");
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- gst_bit_reader_init (&bits, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ gst_bit_reader_init (&bits, map.data, map.size);
gst_bit_reader_skip_unchecked (&bits, skip * 8);
gst_bit_reader_skip_unchecked (&bits, 16);
ret = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return ret;
}
GstBitReader bits;
guint16 sync;
guint8 bsid;
- gpointer data;
- gsize size;
+ GstMapInfo map;
gboolean ret = FALSE;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- gst_bit_reader_init (&bits, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ gst_bit_reader_init (&bits, map.data, map.size);
- GST_MEMDUMP_OBJECT (parse, "AC3 frame sync", data, MIN (size, 16));
+ GST_MEMDUMP_OBJECT (parse, "AC3 frame sync", map.data, MIN (map.size, 16));
gst_bit_reader_skip_unchecked (&bits, skip * 8);
GST_DEBUG_OBJECT (parse, "unexpected bsid %d", bsid);
cleanup:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return ret;
}
gboolean lost_sync, draining, eac, more = FALSE;
guint frmsiz, blocks, sid;
gint have_blocks = 0;
- gpointer data;
- gsize size;
+ GstMapInfo map;
gboolean ret = FALSE;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (G_UNLIKELY (size < 6))
+ if (G_UNLIKELY (map.size < 6))
goto cleanup;
- gst_byte_reader_init (&reader, data, size);
+ gst_byte_reader_init (&reader, map.data, map.size);
off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffff0000, 0x0b770000,
- 0, size);
+ 0, map.size);
GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off);
/* didn't find anything that looks like a sync word, skip */
if (off < 0) {
- *skipsize = size - 3;
+ *skipsize = map.size - 3;
goto cleanup;
}
do {
*framesize += frmsiz;
- if (!gst_byte_reader_skip (&reader, frmsiz) || size < (*framesize + 6)) {
+ if (!gst_byte_reader_skip (&reader, frmsiz)
+ || map.size < (*framesize + 6)) {
more = TRUE;
break;
}
ret = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return ret;
}
GstBaseParseFrame * frame, guint * framesize, gint * skipsize)
{
GstBuffer *buffer;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
gint fsize, mode, dsize;
GstAmrParse *amrparse;
gboolean ret = FALSE;
amrparse = GST_AMR_PARSE (parse);
buffer = frame->buffer;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- dsize = size;
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ dsize = map.size;
GST_LOG ("buffer: %d bytes", dsize);
if (amrparse->need_header) {
if (dsize >= AMR_MIME_HEADER_SIZE &&
- gst_amr_parse_parse_header (amrparse, data, skipsize)) {
+ gst_amr_parse_parse_header (amrparse, map.data, skipsize)) {
amrparse->need_header = FALSE;
gst_base_parse_set_frame_rate (GST_BASE_PARSE (amrparse), 50, 1, 2, 2);
} else {
}
/* Does this look like a possible frame header candidate? */
- if ((data[0] & 0x83) == 0) {
+ if ((map.data[0] & 0x83) == 0) {
/* Yep. Retrieve the frame size */
- mode = (data[0] >> 3) & 0x0F;
+ mode = (map.data[0] >> 3) & 0x0F;
fsize = amrparse->block_size[mode] + 1; /* +1 for the header byte */
/* We recognize this data as a valid frame when:
found = TRUE;
} else if (dsize > fsize) {
/* enough data, check for next sync */
- if ((data[fsize] & 0x83) == 0)
+ if ((map.data[fsize] & 0x83) == 0)
found = TRUE;
} else if (GST_BASE_PARSE_DRAINING (parse)) {
/* not enough, but draining, so ok */
GST_LOG ("sync lost");
done:
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
guint32 sync = 0;
guint size, rate, chans, num_blocks, samples_per_block;
gint off = -1;
- gpointer data;
- gsize bufsize;
+ GstMapInfo map;
gboolean ret = FALSE;
- data = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (G_UNLIKELY (bufsize < 16))
+ if (G_UNLIKELY (map.size < 16))
goto cleanup;
parser_in_sync = !GST_BASE_PARSE_LOST_SYNC (parse);
- gst_byte_reader_init (&r, data, bufsize);
+ gst_byte_reader_init (&r, map.data, map.size);
if (G_LIKELY (parser_in_sync && dcaparse->last_sync != 0)) {
off = gst_byte_reader_masked_scan_uint32 (&r, 0xffffffff,
- dcaparse->last_sync, 0, bufsize);
+ dcaparse->last_sync, 0, map.size);
}
if (G_UNLIKELY (off < 0)) {
- off = gst_dca_parse_find_sync (dcaparse, &r, bufsize, &sync);
+ off = gst_dca_parse_find_sync (dcaparse, &r, map.size, &sync);
}
/* didn't find anything that looks like a sync word, skip */
if (off < 0) {
- *skipsize = bufsize - 3;
+ *skipsize = map.size - 3;
GST_DEBUG_OBJECT (dcaparse, "no sync, skipping %d bytes", *skipsize);
goto cleanup;
}
if (!parser_in_sync && !parser_draining) {
/* check for second frame to be sure */
GST_DEBUG_OBJECT (dcaparse, "resyncing; checking next frame syncword");
- if (bufsize >= (size + 16)) {
+ if (map.size >= (size + 16)) {
guint s2, r2, c2, n2, s3;
gboolean t;
- GST_MEMDUMP ("buf", data, size + 16);
- gst_byte_reader_init (&r, data, bufsize);
+ GST_MEMDUMP ("buf", map.data, size + 16);
+ gst_byte_reader_init (&r, map.data, map.size);
gst_byte_reader_skip_unchecked (&r, size);
if (!gst_dca_parse_parse_header (dcaparse, &r, &s2, &r2, &c2, NULL, NULL,
/* FIXME: baseparse always seems to hand us buffers of min_frame_size
* bytes, which is unhelpful here */
GST_LOG_OBJECT (dcaparse,
- "next sync out of reach (%" G_GSIZE_FORMAT " < %u)", bufsize,
+ "next sync out of reach (%" G_GSIZE_FORMAT " < %u)", map.size,
size + 16);
/* *skipsize = 0; */
/* return FALSE; */
ret = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return ret;
}
guint size, rate, chans, depth, block_size, num_blocks, samples_per_block;
gint endianness;
gboolean terminator;
- gpointer data;
- gsize bufsize;
+ GstMapInfo map;
- data = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
- gst_byte_reader_init (&r, data, bufsize);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ gst_byte_reader_init (&r, map.data, map.size);
if (!gst_dca_parse_parse_header (dcaparse, &r, &size, &rate, &chans, &depth,
&endianness, &num_blocks, &samples_per_block, &terminator))
gst_base_parse_set_frame_rate (parse, rate, block_size, 0, 0);
}
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
/* ERRORS */
{
/* this really shouldn't ever happen */
GST_ELEMENT_ERROR (parse, STREAM, DECODE, (NULL), (NULL));
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
}
GstBaseParseFrame * frame, guint * ret)
{
GstBuffer *buffer;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint max, remaining;
guint i, search_start, search_end;
FrameHeaderCheckReturn header_ret;
gboolean result = FALSE;
buffer = frame->buffer;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- if (size < flacparse->min_framesize)
+ if (map.size < flacparse->min_framesize)
goto need_more;
header_ret =
- gst_flac_parse_frame_header_is_valid (flacparse, data, size, TRUE,
+ gst_flac_parse_frame_header_is_valid (flacparse, map.data, map.size, TRUE,
&block_size);
if (header_ret == FRAME_HEADER_INVALID) {
*ret = 0;
/* mind unknown framesize */
search_start = MAX (2, flacparse->min_framesize);
if (flacparse->max_framesize)
- search_end = MIN (size, flacparse->max_framesize + 9 + 2);
+ search_end = MIN (map.size, flacparse->max_framesize + 9 + 2);
else
- search_end = size;
+ search_end = map.size;
search_end -= 2;
- remaining = size;
+ remaining = map.size;
for (i = search_start; i < search_end; i++, remaining--) {
- if ((GST_READ_UINT16_BE (data + i) & 0xfffe) == 0xfff8) {
+ if ((GST_READ_UINT16_BE (map.data + i) & 0xfffe) == 0xfff8) {
header_ret =
- gst_flac_parse_frame_header_is_valid (flacparse, data + i, remaining,
- FALSE, NULL);
+ gst_flac_parse_frame_header_is_valid (flacparse, map.data + i,
+ remaining, FALSE, NULL);
if (header_ret == FRAME_HEADER_VALID) {
if (flacparse->check_frame_checksums) {
- guint16 actual_crc = gst_flac_calculate_crc16 (data, i - 2);
- guint16 expected_crc = GST_READ_UINT16_BE (data + i - 2);
+ guint16 actual_crc = gst_flac_calculate_crc16 (map.data, i - 2);
+ guint16 expected_crc = GST_READ_UINT16_BE (map.data + i - 2);
if (actual_crc != expected_crc)
continue;
/* For the last frame output everything to the end */
if (G_UNLIKELY (GST_BASE_PARSE_DRAINING (flacparse))) {
if (flacparse->check_frame_checksums) {
- guint16 actual_crc = gst_flac_calculate_crc16 (data, size - 2);
- guint16 expected_crc = GST_READ_UINT16_BE (data + size - 2);
+ guint16 actual_crc = gst_flac_calculate_crc16 (map.data, map.size - 2);
+ guint16 expected_crc = GST_READ_UINT16_BE (map.data + map.size - 2);
if (actual_crc == expected_crc) {
- *ret = size;
+ *ret = map.size;
flacparse->block_size = block_size;
result = TRUE;
goto cleanup;
}
} else {
- *ret = size;
+ *ret = map.size;
flacparse->block_size = block_size;
result = TRUE;
goto cleanup;
max = flacparse->max_framesize + 16;
if (max == 16)
max = 1 << 24;
- *ret = MIN (size + 4096, max);
+ *ret = MIN (map.size + 4096, max);
result = TRUE;
cleanup:
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return result;
}
{
GstFlacParse *flacparse = GST_FLAC_PARSE (parse);
GstBuffer *buffer = frame->buffer;
- guint8 *data;
- gsize bufsize;
+ GstMapInfo map;
gboolean result = TRUE;
- data = gst_buffer_map (buffer, &bufsize, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- if (G_UNLIKELY (bufsize < 4)) {
+ if (G_UNLIKELY (map.size < 4)) {
result = FALSE;
goto cleanup;
}
if (flacparse->state == GST_FLAC_PARSE_STATE_INIT) {
- if (memcmp (data, "fLaC", 4) == 0) {
+ if (memcmp (map.data, "fLaC", 4) == 0) {
GST_DEBUG_OBJECT (flacparse, "fLaC marker found");
*framesize = 4;
goto cleanup;
}
- if (data[0] == 0xff && (data[1] >> 2) == 0x3e) {
+ if (map.data[0] == 0xff && (map.data[1] >> 2) == 0x3e) {
GST_DEBUG_OBJECT (flacparse, "Found headerless FLAC");
/* Minimal size of a frame header */
gst_base_parse_set_min_frame_size (GST_BASE_PARSE (flacparse), 9);
}
if (flacparse->state == GST_FLAC_PARSE_STATE_HEADERS) {
- guint size = 4 + ((data[1] << 16) | (data[2] << 8) | (data[3]));
+ guint size = 4 + ((map.data[1] << 16) | (map.data[2] << 8) | (map.data[3]));
GST_DEBUG_OBJECT (flacparse, "Found metadata block of size %u", size);
*framesize = size;
goto cleanup;
}
- if ((GST_READ_UINT16_BE (data) & 0xfffe) == 0xfff8) {
+ if ((GST_READ_UINT16_BE (map.data) & 0xfffe) == 0xfff8) {
gboolean ret;
guint next;
}
if (next == 0) {
- } else if (next > bufsize) {
+ } else if (next > map.size) {
GST_DEBUG_OBJECT (flacparse, "Requesting %u bytes", next);
*skipsize = 0;
gst_base_parse_set_min_frame_size (parse, next);
goto cleanup;
} else {
GST_ERROR_OBJECT (flacparse,
- "Giving up on invalid frame (%" G_GSIZE_FORMAT " bytes)", bufsize);
+ "Giving up on invalid frame (%" G_GSIZE_FORMAT " bytes)", map.size);
result = FALSE;
goto cleanup;
}
GstByteReader reader;
gint off;
- gst_byte_reader_init (&reader, data, bufsize);
+ gst_byte_reader_init (&reader, map.data, map.size);
off =
gst_byte_reader_masked_scan_uint32 (&reader, 0xfffc0000, 0xfff80000,
- 0, bufsize);
+ 0, map.size);
if (off > 0) {
GST_DEBUG_OBJECT (parse, "Possible sync at buffer offset %d", off);
goto cleanup;
} else {
GST_DEBUG_OBJECT (flacparse, "Sync code not found");
- *skipsize = bufsize - 3;
+ *skipsize = map.size - 3;
result = FALSE;
goto cleanup;
}
result = FALSE;
cleanup:
- gst_buffer_unmap (buffer, data, bufsize);
+ gst_buffer_unmap (buffer, &map);
return result;
}
gst_flac_parse_handle_streaminfo (GstFlacParse * flacparse, GstBuffer * buffer)
{
GstBitReader reader;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- gst_bit_reader_init (&reader, data, size);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ gst_bit_reader_init (&reader, map.data, map.size);
- if (size != 4 + 34) {
+ if (map.size != 4 + 34) {
GST_ERROR_OBJECT (flacparse,
- "Invalid metablock size for STREAMINFO: %" G_GSIZE_FORMAT "", size);
+ "Invalid metablock size for STREAMINFO: %" G_GSIZE_FORMAT "", map.size);
goto failure;
}
GST_FORMAT_DEFAULT, flacparse->total_samples, 0);
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
GST_DEBUG_OBJECT (flacparse, "STREAMINFO:\n"
"\tmin/max blocksize: %u/%u,\n"
error:
GST_ERROR_OBJECT (flacparse, "Failed to read data");
failure:
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
gst_flac_parse_handle_vorbiscomment (GstFlacParse * flacparse,
GstBuffer * buffer)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- flacparse->tags = gst_tag_list_from_vorbiscomment (data, size, data, 4, NULL);
- gst_buffer_unmap (buffer, data, size);
+ flacparse->tags =
+ gst_tag_list_from_vorbiscomment (map.data, map.size, map.data, 4, NULL);
+ gst_buffer_unmap (buffer, &map);
if (flacparse->tags == NULL) {
GST_ERROR_OBJECT (flacparse, "Invalid vorbiscomment block");
gst_flac_parse_handle_picture (GstFlacParse * flacparse, GstBuffer * buffer)
{
GstByteReader reader;
- guint8 *data;
- gsize bufsize;
+ GstMapInfo map;
guint32 img_len = 0, img_type = 0;
guint32 img_mimetype_len = 0, img_description_len = 0;
- data = gst_buffer_map (buffer, &bufsize, NULL, GST_MAP_READ);
- gst_byte_reader_init (&reader, data, bufsize);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ gst_byte_reader_init (&reader, map.data, map.size);
if (!gst_byte_reader_skip (&reader, 4))
goto error;
flacparse->tags = gst_tag_list_new_empty ();
gst_tag_list_add_id3_image (flacparse->tags,
- data + gst_byte_reader_get_pos (&reader), img_len, img_type);
+ map.data + gst_byte_reader_get_pos (&reader), img_len, img_type);
if (gst_tag_list_is_empty (flacparse->tags)) {
gst_tag_list_free (flacparse->tags);
flacparse->tags = NULL;
}
- gst_buffer_unmap (buffer, data, bufsize);
+ gst_buffer_unmap (buffer, &map);
return TRUE;
error:
GST_ERROR_OBJECT (flacparse, "Error reading data");
- gst_buffer_unmap (buffer, data, bufsize);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
{
GstByteReader br;
gint64 offset = 0, samples = 0;
- gpointer data;
- gsize bufsize;
+ GstMapInfo map;
GST_DEBUG_OBJECT (flacparse,
"parsing seektable; base offset %" G_GINT64_FORMAT, boffset);
if (boffset <= 0)
goto exit;
- data = gst_buffer_map (flacparse->seektable, &bufsize, NULL, GST_MAP_READ);
- gst_byte_reader_init (&br, data, bufsize);
+ gst_buffer_map (flacparse->seektable, &map, GST_MAP_READ);
+ gst_byte_reader_init (&br, map.data, map.size);
/* skip header */
if (!gst_byte_reader_skip (&br, 4))
}
done:
- gst_buffer_unmap (flacparse->seektable, data, bufsize);
+ gst_buffer_unmap (flacparse->seektable, &map);
exit:
gst_buffer_unref (flacparse->seektable);
flacparse->seektable = NULL;
for (l = flacparse->headers; l; l = l->next) {
GstBuffer *header = l->data;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (header, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (header, &map, GST_MAP_READ);
GST_BUFFER_FLAG_SET (header, GST_BUFFER_FLAG_IN_CAPS);
- if (size == 4 && memcmp (data, "fLaC", 4) == 0) {
+ if (map.size == 4 && memcmp (map.data, "fLaC", 4) == 0) {
marker = header;
- } else if (size > 1 && (data[0] & 0x7f) == 0) {
+ } else if (map.size > 1 && (map.data[0] & 0x7f) == 0) {
streaminfo = header;
- } else if (size > 1 && (data[0] & 0x7f) == 4) {
+ } else if (map.size > 1 && (map.data[0] & 0x7f) == 4) {
vorbiscomment = header;
}
- gst_buffer_unmap (header, data, size);
+ gst_buffer_unmap (header, &map);
}
if (marker == NULL || streaminfo == NULL || vorbiscomment == NULL) {
{
GstBuffer *buf;
guint16 num;
- guint8 *sinfodata, *writedata;
- gsize sinfosize, writesize;
+ GstMapInfo sinfomap, writemap;
- sinfodata = gst_buffer_map (streaminfo, &sinfosize, NULL, GST_MAP_READ);
+ gst_buffer_map (streaminfo, &sinfomap, GST_MAP_READ);
/* minus one for the marker that is merged with streaminfo here */
num = g_list_length (flacparse->headers) - 1;
- buf = gst_buffer_new_and_alloc (13 + sinfosize);
- writedata = gst_buffer_map (buf, &writesize, NULL, GST_MAP_WRITE);
-
- writedata[0] = 0x7f;
- memcpy (writedata + 1, "FLAC", 4);
- writedata[5] = 0x01; /* mapping version major */
- writedata[6] = 0x00; /* mapping version minor */
- writedata[7] = (num & 0xFF00) >> 8;
- writedata[8] = (num & 0x00FF) >> 0;
- memcpy (writedata + 9, "fLaC", 4);
- memcpy (writedata + 13, sinfodata, sinfosize);
+ buf = gst_buffer_new_and_alloc (13 + sinfomap.size);
+ gst_buffer_map (buf, &writemap, GST_MAP_WRITE);
+
+ writemap.data[0] = 0x7f;
+ memcpy (writemap.data + 1, "FLAC", 4);
+ writemap.data[5] = 0x01; /* mapping version major */
+ writemap.data[6] = 0x00; /* mapping version minor */
+ writemap.data[7] = (num & 0xFF00) >> 8;
+ writemap.data[8] = (num & 0x00FF) >> 0;
+ memcpy (writemap.data + 9, "fLaC", 4);
+ memcpy (writemap.data + 13, sinfomap.data, sinfomap.size);
_value_array_append_buffer (&array, buf);
- gst_buffer_unmap (streaminfo, sinfodata, sinfosize);
- gst_buffer_unmap (buf, writedata, writesize);
+ gst_buffer_unmap (streaminfo, &sinfomap);
+ gst_buffer_unmap (buf, &writemap);
gst_buffer_unref (buf);
}
gst_flac_parse_generate_headers (GstFlacParse * flacparse)
{
GstBuffer *marker, *streaminfo, *vorbiscomment;
- guint8 *data;
- gsize bufsize;
+ GstMapInfo map;
marker = gst_buffer_new_and_alloc (4);
- data = gst_buffer_map (marker, &bufsize, NULL, GST_MAP_WRITE);
- memcpy (data, "fLaC", 4);
- gst_buffer_unmap (marker, data, bufsize);
+ gst_buffer_map (marker, &map, GST_MAP_WRITE);
+ memcpy (map.data, "fLaC", 4);
+ gst_buffer_unmap (marker, &map);
GST_BUFFER_TIMESTAMP (marker) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (marker) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET (marker) = 0;
flacparse->headers = g_list_append (flacparse->headers, marker);
streaminfo = gst_buffer_new_and_alloc (4 + 34);
- data = gst_buffer_map (streaminfo, &bufsize, NULL, GST_MAP_WRITE);
- memset (data, 0, 4 + 34);
+ gst_buffer_map (streaminfo, &map, GST_MAP_WRITE);
+ memset (map.data, 0, 4 + 34);
/* metadata block header */
- data[0] = 0x00; /* is_last = 0; type = 0; */
- data[1] = 0x00; /* length = 34; */
- data[2] = 0x00;
- data[3] = 0x22;
+ map.data[0] = 0x00; /* is_last = 0; type = 0; */
+ map.data[1] = 0x00; /* length = 34; */
+ map.data[2] = 0x00;
+ map.data[3] = 0x22;
/* streaminfo */
- data[4] = (flacparse->block_size >> 8) & 0xff; /* min blocksize = blocksize; */
- data[5] = (flacparse->block_size) & 0xff;
- data[6] = (flacparse->block_size >> 8) & 0xff; /* max blocksize = blocksize; */
- data[7] = (flacparse->block_size) & 0xff;
+ map.data[4] = (flacparse->block_size >> 8) & 0xff; /* min blocksize = blocksize; */
+ map.data[5] = (flacparse->block_size) & 0xff;
+ map.data[6] = (flacparse->block_size >> 8) & 0xff; /* max blocksize = blocksize; */
+ map.data[7] = (flacparse->block_size) & 0xff;
- data[8] = 0x00; /* min framesize = 0; */
- data[9] = 0x00;
- data[10] = 0x00;
- data[11] = 0x00; /* max framesize = 0; */
- data[12] = 0x00;
- data[13] = 0x00;
+ map.data[8] = 0x00; /* min framesize = 0; */
+ map.data[9] = 0x00;
+ map.data[10] = 0x00;
+ map.data[11] = 0x00; /* max framesize = 0; */
+ map.data[12] = 0x00;
+ map.data[13] = 0x00;
- data[14] = (flacparse->samplerate >> 12) & 0xff;
- data[15] = (flacparse->samplerate >> 4) & 0xff;
- data[16] = (flacparse->samplerate >> 0) & 0xf0;
+ map.data[14] = (flacparse->samplerate >> 12) & 0xff;
+ map.data[15] = (flacparse->samplerate >> 4) & 0xff;
+ map.data[16] = (flacparse->samplerate >> 0) & 0xf0;
- data[16] |= (flacparse->channels - 1) << 1;
+ map.data[16] |= (flacparse->channels - 1) << 1;
- data[16] |= ((flacparse->bps - 1) >> 4) & 0x01;
- data[17] = (((flacparse->bps - 1)) & 0x0f) << 4;
+ map.data[16] |= ((flacparse->bps - 1) >> 4) & 0x01;
+ map.data[17] = (((flacparse->bps - 1)) & 0x0f) << 4;
{
gint64 duration;
GST_FORMAT_TIME, &duration)) {
duration = GST_CLOCK_TIME_TO_FRAMES (duration, flacparse->samplerate);
- data[17] |= (duration >> 32) & 0xff;
- data[18] |= (duration >> 24) & 0xff;
- data[19] |= (duration >> 16) & 0xff;
- data[20] |= (duration >> 8) & 0xff;
- data[21] |= (duration >> 0) & 0xff;
+ map.data[17] |= (duration >> 32) & 0xff;
+ map.data[18] |= (duration >> 24) & 0xff;
+ map.data[19] |= (duration >> 16) & 0xff;
+ map.data[20] |= (duration >> 8) & 0xff;
+ map.data[21] |= (duration >> 0) & 0xff;
}
}
/* MD5 = 0; */
- gst_buffer_unmap (streaminfo, data, bufsize);
+ gst_buffer_unmap (streaminfo, &map);
GST_BUFFER_TIMESTAMP (streaminfo) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (streaminfo) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET (streaminfo) = 0;
sizeof (header), NULL);
gst_tag_list_free (taglist);
- data = gst_buffer_map (vorbiscomment, &bufsize, NULL, GST_MAP_WRITE);
+ gst_buffer_map (vorbiscomment, &map, GST_MAP_WRITE);
/* Get rid of framing bit */
- if (data[bufsize - 1] == 1) {
+ if (map.data[map.size - 1] == 1) {
GstBuffer *sub;
sub =
gst_buffer_copy_region (vorbiscomment, GST_BUFFER_COPY_ALL, 0,
- bufsize - 1);
- gst_buffer_unmap (vorbiscomment, data, bufsize);
+ map.size - 1);
+ gst_buffer_unmap (vorbiscomment, &map);
gst_buffer_unref (vorbiscomment);
vorbiscomment = sub;
- data = gst_buffer_map (vorbiscomment, &bufsize, NULL, GST_MAP_WRITE);
+ gst_buffer_map (vorbiscomment, &map, GST_MAP_WRITE);
}
- size = bufsize - 4;
- data[1] = ((size & 0xFF0000) >> 16);
- data[2] = ((size & 0x00FF00) >> 8);
- data[3] = (size & 0x0000FF);
+ size = map.size - 4;
+ map.data[1] = ((size & 0xFF0000) >> 16);
+ map.data[2] = ((size & 0x00FF00) >> 8);
+ map.data[3] = (size & 0x0000FF);
+ gst_buffer_unmap (vorbiscomment, &map);
- gst_buffer_unmap (vorbiscomment, data, bufsize);
GST_BUFFER_TIMESTAMP (vorbiscomment) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (vorbiscomment) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET (vorbiscomment) = 0;
{
GstFlacParse *flacparse = GST_FLAC_PARSE (parse);
GstBuffer *buffer = frame->buffer;
- guint8 *data = NULL;
- gsize bufsize;
+ GstMapInfo map;
GstFlowReturn res = GST_FLOW_ERROR;
- data = gst_buffer_map (buffer, &bufsize, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
if (flacparse->state == GST_FLAC_PARSE_STATE_INIT) {
GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE;
res = GST_BASE_PARSE_FLOW_DROPPED;
} else if (flacparse->state == GST_FLAC_PARSE_STATE_HEADERS) {
- gboolean is_last = ((data[0] & 0x80) == 0x80);
- guint type = (data[0] & 0x7F);
+ gboolean is_last = ((map.data[0] & 0x80) == 0x80);
+ guint type = (map.data[0] & 0x7F);
if (type == 127) {
GST_WARNING_OBJECT (flacparse, "Invalid metadata block type");
flacparse->offset = GST_BUFFER_OFFSET (buffer);
ret =
gst_flac_parse_frame_header_is_valid (flacparse,
- data, bufsize, TRUE, NULL);
+ map.data, map.size, TRUE, NULL);
if (ret != FRAME_HEADER_VALID) {
GST_ERROR_OBJECT (flacparse,
"Baseclass didn't provide a complete frame");
}
cleanup:
- if (data)
- gst_buffer_unmap (buffer, data, bufsize);
+ gst_buffer_unmap (buffer, &map);
return res;
}
guint32 header, int bpf, gboolean at_eos, gint * valid)
{
guint32 next_header;
- guint8 *data;
- gsize available;
+ GstMapInfo map;
gboolean res = TRUE;
int frames_found = 1;
int offset = bpf;
- data = gst_buffer_map (buf, &available, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
while (frames_found < MIN_RESYNC_FRAMES) {
/* Check if we have enough data for all these frames, plus the next
frame header. */
- if (available < offset + 4) {
+ if (map.size < offset + 4) {
if (at_eos) {
/* Running out of data at EOS is fine; just accept it */
*valid = TRUE;
}
}
- next_header = GST_READ_UINT32_BE (data + offset);
+ next_header = GST_READ_UINT32_BE (map.data + offset);
GST_DEBUG_OBJECT (mp3parse, "At %d: header=%08X, header2=%08X, bpf=%d",
offset, (unsigned int) header, (unsigned int) next_header, bpf);
*valid = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, available);
+ gst_buffer_unmap (buf, &map);
return res;
}
gboolean lost_sync, draining, valid, caps_change;
guint32 header;
guint bitrate, layer, rate, channels, version, mode, crc;
- guint8 *data;
- gsize bufsize;
+ GstMapInfo map;
gboolean res = FALSE;
- data = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
- if (G_UNLIKELY (bufsize < 6))
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (G_UNLIKELY (map.size < 6))
goto cleanup;
- gst_byte_reader_init (&reader, data, bufsize);
+ gst_byte_reader_init (&reader, map.data, map.size);
off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffe00000, 0xffe00000,
- 0, bufsize);
+ 0, map.size);
GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off);
/* didn't find anything that looks like a sync word, skip */
if (off < 0) {
- *skipsize = bufsize - 3;
+ *skipsize = map.size - 3;
goto cleanup;
}
}
/* make sure the values in the frame header look sane */
- header = GST_READ_UINT32_BE (data);
+ header = GST_READ_UINT32_BE (map.data);
if (!gst_mpeg_audio_parse_head_check (mp3parse, header)) {
*skipsize = 1;
goto cleanup;
res = TRUE;
cleanup:
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return res;
}
guint64 avail;
gint64 upstream_total_bytes = 0;
guint32 read_id_xing = 0, read_id_vbri = 0;
- guint8 *data, *origdata;
- gsize bufsize;
+ GstMapInfo map;
+ guint8 *data;
guint bitrate;
if (mp3parse->sent_codec_tag)
offset_vbri += 4;
/* Check if we have enough data to read the Xing header */
- origdata = data = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
- avail = bufsize;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ avail = map.size;
if (avail >= offset_xing + 4) {
read_id_xing = GST_READ_UINT32_BE (data + offset_xing);
goto cleanup;
}
- data = origdata;
+ data = map.data;
data += offset_vbri + 26;
/* VBRI seek table: frame/seek_frames -> byte */
gst_base_parse_set_average_bitrate (GST_BASE_PARSE (mp3parse), bitrate);
cleanup:
- gst_buffer_unmap (buf, origdata, bufsize);
+ gst_buffer_unmap (buf, &map);
}
static GstFlowReturn
{
GstMpegAudioParse *mp3parse = GST_MPEG_AUDIO_PARSE (parse);
GstBuffer *buf = frame->buffer;
- guint8 *data;
- gsize bufsize;
+ GstMapInfo map;
guint bitrate, layer, rate, channels, version, mode, crc;
- data = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
- if (G_UNLIKELY (bufsize < 4))
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (G_UNLIKELY (map.size < 4))
goto short_buffer;
if (!mp3_type_frame_length_from_header (mp3parse,
- GST_READ_UINT32_BE (data),
+ GST_READ_UINT32_BE (map.data),
&version, &layer, &channels, &bitrate, &rate, &mode, &crc))
goto broken_header;
mp3parse->last_crc = crc;
mp3parse->last_mode = mode;
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
/* ERRORS */
broken_header:
{
/* this really shouldn't ever happen */
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
GST_ELEMENT_ERROR (parse, STREAM, DECODE, (NULL), (NULL));
return GST_FLOW_ERROR;
}
short_buffer:
{
- gst_buffer_unmap (buf, data, bufsize);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
}
gst_avi_demux_parse_superindex (GstAviDemux * avi,
GstBuffer * buf, guint64 ** _indexes)
{
+ GstMapInfo map;
guint8 *data;
guint16 bpe = 16;
guint32 num, i;
*_indexes = NULL;
if (buf) {
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
} else {
data = NULL;
size = 0;
indexes[i] = GST_BUFFER_OFFSET_NONE;
*_indexes = indexes;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return TRUE;
"Not enough data to parse superindex (%" G_GSIZE_FORMAT
" available, 24 needed)", size);
if (buf) {
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
}
return FALSE;
{
GST_ERROR_OBJECT (avi, "invalid index parameters (num = %d, bpe = %d)",
num, bpe);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return FALSE;
}
gst_avi_demux_parse_subindex (GstAviDemux * avi, GstAviStream * stream,
GstBuffer * buf)
{
+ GstMapInfo map;
guint8 *data;
guint16 bpe;
guint32 num, i;
guint64 baseoff;
- gsize size;
if (buf == NULL)
return TRUE;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+
/* check size */
- if (size < 24)
+ if (map.size < 24)
goto too_small;
/* We don't support index-data yet */
for (i = 0; i < num; i++) {
GstAviIndexEntry entry;
- if (size < 24 + bpe * (i + 1))
+ if (map.size < 24 + bpe * (i + 1))
break;
/* fill in offset and size. offset contains the keyframe flag in the
goto out_of_mem;
}
done:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return TRUE;
{
GST_ERROR_OBJECT (avi,
"Not enough data to parse subindex (%" G_GSIZE_FORMAT
- " available, 24 needed)", size);
+ " available, 24 needed)", map.size);
goto done; /* continue */
}
not_implemented:
{
GST_ELEMENT_ERROR (avi, STREAM, NOT_IMPLEMENTED, (NULL),
("Subindex-is-data is not implemented"));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return FALSE;
}
("Cannot allocate memory for %u*%u=%u bytes",
(guint) sizeof (GstAviIndexEntry), num,
(guint) sizeof (GstAviIndexEntry) * num));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return FALSE;
}
if (G_UNLIKELY (size & 1)) {
GstBuffer *obuf;
- guint8 *data;
+ GstMapInfo map;
GST_DEBUG_OBJECT (avi, "rounding up dubious list size %" G_GSIZE_FORMAT,
size);
obuf = gst_buffer_new_and_alloc (size + 1);
- data = gst_buffer_map (obuf, NULL, NULL, GST_MAP_WRITE);
- gst_buffer_extract (*buf, 0, data, size);
+ gst_buffer_map (obuf, &map, GST_MAP_WRITE);
+ gst_buffer_extract (*buf, 0, map.data, size);
/* assume 0 padding, at least makes outcome deterministic */
- data[size] = 0;
- gst_buffer_unmap (obuf, data, size + 1);
+ map.data[size] = 0;
+ gst_buffer_unmap (obuf, &map);
gst_buffer_replace (buf, obuf);
}
}
case GST_RIFF_TAG_strn:
g_free (stream->name);
if (sub != NULL) {
- gchar *bdata;
- gsize bsize;
+ GstMapInfo map;
- bdata = gst_buffer_map (sub, &bsize, NULL, GST_MAP_READ);
- stream->name = g_strndup (bdata, bsize);
- gst_buffer_unmap (sub, bdata, bsize);
+ gst_buffer_map (sub, &map, GST_MAP_READ);
+ stream->name = g_strndup ((gchar *) map.data, map.size);
+ gst_buffer_unmap (sub, &map);
gst_buffer_unref (sub);
sub = NULL;
} else {
switch (tag) {
case GST_RIFF_TAG_dmlh:{
gst_riff_dmlh dmlh, *_dmlh;
- gsize size;
- guint8 *data;
+ GstMapInfo map;
/* sub == NULL is possible and means an empty buffer */
if (sub == NULL)
goto next;
- data = gst_buffer_map (sub, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (sub, &map, GST_MAP_READ);
/* check size */
- if (size < sizeof (gst_riff_dmlh)) {
+ if (map.size < sizeof (gst_riff_dmlh)) {
GST_ERROR_OBJECT (avi,
"DMLH entry is too small (%" G_GSIZE_FORMAT " bytes, %d needed)",
- size, (int) sizeof (gst_riff_dmlh));
- gst_buffer_unmap (sub, data, size);
+ map.size, (int) sizeof (gst_riff_dmlh));
+ gst_buffer_unmap (sub, &map);
goto next;
}
- _dmlh = (gst_riff_dmlh *) data;
+ _dmlh = (gst_riff_dmlh *) map.data;
dmlh.totalframes = GST_READ_UINT32_LE (&_dmlh->totalframes);
- gst_buffer_unmap (sub, data, size);
+ gst_buffer_unmap (sub, &map);
GST_INFO_OBJECT (avi, "dmlh tag found: totalframes: %u",
dmlh.totalframes);
static gboolean
gst_avi_demux_parse_index (GstAviDemux * avi, GstBuffer * buf)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint i, num, n;
gst_riff_index_entry *index;
GstClockTime stamp;
if (!buf)
return FALSE;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
stamp = gst_util_get_timestamp ();
/* see how many items in the index */
- num = size / sizeof (gst_riff_index_entry);
+ num = map.size / sizeof (gst_riff_index_entry);
if (num == 0)
goto empty_list;
GST_INFO_OBJECT (avi, "Parsing index, nr_entries = %6d", num);
- index = (gst_riff_index_entry *) data;
+ index = (gst_riff_index_entry *) map.data;
/* figure out if the index is 0 based or relative to the MOVI start */
entry.offset = GST_READ_UINT32_LE (&index[0].offset);
n++;
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
/* get stream stats now */
empty_list:
{
GST_DEBUG_OBJECT (avi, "empty index");
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return FALSE;
}
("Cannot allocate memory for %u*%u=%u bytes",
(guint) sizeof (GstAviIndexEntry), num,
(guint) sizeof (GstAviIndexEntry) * num));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return FALSE;
}
GstBuffer *buf;
guint32 tag;
guint32 size;
- gsize bsize;
- guint8 *bdata;
+ GstMapInfo map;
GST_DEBUG ("demux stream index at offset %" G_GUINT64_FORMAT, offset);
if (res != GST_FLOW_OK)
goto pull_failed;
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- if (bsize < 8)
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (map.size < 8)
goto too_small;
/* check tag first before blindy trying to read 'size' bytes */
- tag = GST_READ_UINT32_LE (bdata);
- size = GST_READ_UINT32_LE (bdata + 4);
+ tag = GST_READ_UINT32_LE (map.data);
+ size = GST_READ_UINT32_LE (map.data + 4);
if (tag == GST_RIFF_TAG_LIST) {
/* this is the movi tag */
GST_DEBUG_OBJECT (avi, "skip LIST chunk, size %" G_GUINT32_FORMAT,
(8 + GST_ROUND_UP_2 (size)));
offset += 8 + GST_ROUND_UP_2 (size);
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
res = gst_pad_pull_range (avi->sinkpad, offset, 8, &buf);
if (res != GST_FLOW_OK)
goto pull_failed;
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- if (bsize < 8)
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (map.size < 8)
goto too_small;
- tag = GST_READ_UINT32_LE (bdata);
- size = GST_READ_UINT32_LE (bdata + 4);
+ tag = GST_READ_UINT32_LE (map.data);
+ size = GST_READ_UINT32_LE (map.data + 4);
}
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
if (tag != GST_RIFF_TAG_idx1)
too_small:
{
GST_DEBUG_OBJECT (avi, "Buffer is too small");
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return;
}
{
GstFlowReturn res = GST_FLOW_OK;
GstBuffer *buf = NULL;
- gsize bufsize;
- guint8 *bufdata;
+ GstMapInfo map;
res = gst_pad_pull_range (avi->sinkpad, offset, 8, &buf);
if (res != GST_FLOW_OK)
goto pull_failed;
- bufdata = gst_buffer_map (buf, &bufsize, NULL, GST_MAP_READ);
- if (bufsize != 8)
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (map.size != 8)
goto wrong_size;
- *tag = GST_READ_UINT32_LE (bufdata);
- *size = GST_READ_UINT32_LE (bufdata + 4);
+ *tag = GST_READ_UINT32_LE (map.data);
+ *size = GST_READ_UINT32_LE (map.data + 4);
GST_LOG_OBJECT (avi, "Tag[%" GST_FOURCC_FORMAT "] (size:%d) %"
G_GINT64_FORMAT " -- %" G_GINT64_FORMAT, GST_FOURCC_ARGS (*tag),
*size, offset + 8, offset + 8 + (gint64) * size);
done:
- gst_buffer_unmap (buf, bufdata, bufsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return res;
wrong_size:
{
GST_DEBUG_OBJECT (avi, "got %" G_GSIZE_FORMAT " bytes which is <> 8 bytes",
- bufsize);
+ map.size);
res = GST_FLOW_ERROR;
goto done;
}
static void
gst_avi_demux_parse_idit (GstAviDemux * avi, GstBuffer * buf)
{
- gchar *data, *ptr;
- gsize size, left;
+ GstMapInfo map;
+ gchar *ptr;
+ gsize left;
gchar *safedata = NULL;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
/*
* According to:
* http://www.eden-foundation.org/products/code/film_date_stamp/index.html
*/
/* skip eventual initial whitespace */
- ptr = data;
- left = size;
+ ptr = (gchar *) map.data;
+ left = map.size;
while (left > 0 && g_ascii_isspace (ptr[0])) {
ptr++;
non_parsable:
GST_WARNING_OBJECT (avi, "IDIT tag has no parsable info");
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
}
/*
/* now, read the elements from the header until the end */
while (gst_riff_parse_chunk (element, buf, &offset, &tag, &sub)) {
- gsize size;
- guint8 *data;
+ GstMapInfo map;
/* sub can be NULL on empty tags */
if (!sub)
continue;
- data = gst_buffer_map (sub, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (sub, &map, GST_MAP_READ);
switch (tag) {
case GST_RIFF_TAG_LIST:
- if (size < 4)
+ if (map.size < 4)
goto next;
- switch (GST_READ_UINT32_LE (data)) {
+ switch (GST_READ_UINT32_LE (map.data)) {
case GST_RIFF_LIST_strl:
if (!(gst_avi_demux_parse_stream (avi, sub))) {
GST_ELEMENT_WARNING (avi, STREAM, DEMUX, (NULL),
default:
GST_WARNING_OBJECT (avi,
"Unknown list %" GST_FOURCC_FORMAT " in AVI header",
- GST_FOURCC_ARGS (GST_READ_UINT32_LE (data)));
- GST_MEMDUMP_OBJECT (avi, "Unknown list", data, size);
+ GST_FOURCC_ARGS (GST_READ_UINT32_LE (map.data)));
+ GST_MEMDUMP_OBJECT (avi, "Unknown list", map.data, map.size);
/* fall-through */
case GST_RIFF_TAG_JUNQ:
case GST_RIFF_TAG_JUNK:
GST_WARNING_OBJECT (avi,
"Unknown tag %" GST_FOURCC_FORMAT " in AVI header at off %d",
GST_FOURCC_ARGS (tag), offset);
- GST_MEMDUMP_OBJECT (avi, "Unknown tag", data, size);
+ GST_MEMDUMP_OBJECT (avi, "Unknown tag", map.data, map.size);
/* fall-through */
case GST_RIFF_TAG_JUNQ:
case GST_RIFF_TAG_JUNK:
next:
if (sub) {
- gst_buffer_unmap (sub, data, size);
+ gst_buffer_unmap (sub, &map);
gst_buffer_unref (sub);
}
sub = NULL;
/* Now, find the data (i.e. skip all junk between header and data) */
do {
+ GstMapInfo map;
guint size;
- gsize bsize;
- guint8 *data;
guint32 tag, ltag;
res = gst_pad_pull_range (avi->sinkpad, avi->offset, 12, &buf);
return GST_FLOW_ERROR;
}
- data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- tag = GST_READ_UINT32_LE (data);
- size = GST_READ_UINT32_LE (data + 4);
- ltag = GST_READ_UINT32_LE (data + 8);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ tag = GST_READ_UINT32_LE (map.data);
+ size = GST_READ_UINT32_LE (map.data + 4);
+ ltag = GST_READ_UINT32_LE (map.data + 8);
GST_DEBUG ("tag %" GST_FOURCC_FORMAT ", size %u",
GST_FOURCC_ARGS (tag), size);
- GST_MEMDUMP ("Tag content", data, bsize);
- gst_buffer_unmap (buf, data, bsize);
+ GST_MEMDUMP ("Tag content", map.data, map.size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
switch (tag) {
GST_DEBUG_OBJECT (avi, "couldn't read INFO chunk");
goto pull_range_failed;
}
- data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- GST_MEMDUMP ("Junk", data, bsize);
- gst_buffer_unmap (buf, data, bsize);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ GST_MEMDUMP ("Junk", map.data, map.size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
}
avi->offset += 8 + GST_ROUND_UP_2 (size);
GstStructure *s;
gint y, w, h;
gint bpp, stride;
- guint8 *tmp = NULL, *data;
- gsize size;
+ guint8 *tmp = NULL;
+ GstMapInfo map;
GstCaps *caps;
if (stream->strh->type != GST_RIFF_FCC_vids)
buf = gst_buffer_make_writable (buf);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
- if (size < (stride * h)) {
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
+ if (map.size < (stride * h)) {
GST_WARNING ("Buffer is smaller than reported Width x Height x Depth");
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return buf;
}
tmp = g_malloc (stride);
for (y = 0; y < h / 2; y++) {
- swap_line (data + stride * y, data + stride * (h - 1 - y), tmp, stride);
+ swap_line (map.data + stride * y, map.data + stride * (h - 1 - y), tmp,
+ stride);
}
g_free (tmp);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return buf;
}
gst_avi_mux_audsink_scan_mpeg_audio (GstAviMux * avimux, GstAviPad * avipad,
GstBuffer * buffer)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint spf;
guint32 header;
gulong layer;
gulong version;
gint lsf, mpg25;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- if (size < 4)
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ if (map.size < 4)
goto not_parsed;
- header = GST_READ_UINT32_BE (data);
+ header = GST_READ_UINT32_BE (map.data);
if ((header & 0xffe00000) != 0xffe00000)
goto not_parsed;
goto cbr_fallback;
}
done:
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_OK;
GstByteWriter bw;
GSList *node;
guint avih, riff, hdrl;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
GST_DEBUG_OBJECT (avimux, "creating avi header, data_size %u, idx_size %u",
avimux->data_size, avimux->idx_size);
gst_byte_writer_put_uint32_le (&bw, vidpad->vids.num_colors);
gst_byte_writer_put_uint32_le (&bw, vidpad->vids.imp_colors);
if (vidpad->vids_codec_data) {
- bdata =
- gst_buffer_map (vidpad->vids_codec_data, &bsize, NULL,
- GST_MAP_READ);
- gst_byte_writer_put_data (&bw, bdata, bsize);
- gst_buffer_unmap (vidpad->vids_codec_data, bdata, bsize);
+ gst_buffer_map (vidpad->vids_codec_data, &map, GST_MAP_READ);
+ gst_byte_writer_put_data (&bw, map.data, map.size);
+ gst_buffer_unmap (vidpad->vids_codec_data, &map);
}
gst_avi_mux_end_chunk (&bw, strf);
gst_byte_writer_put_uint16_le (&bw, audpad->auds.size);
gst_byte_writer_put_uint16_le (&bw, codec_size);
if (audpad->auds_codec_data) {
- bdata =
- gst_buffer_map (audpad->auds_codec_data, &bsize, NULL,
- GST_MAP_READ);
- gst_byte_writer_put_data (&bw, bdata, bsize);
- gst_buffer_unmap (vidpad->vids_codec_data, bdata, bsize);
+ gst_buffer_map (audpad->auds_codec_data, &map, GST_MAP_READ);
+ gst_byte_writer_put_data (&bw, map.data, map.size);
+ gst_buffer_unmap (vidpad->vids_codec_data, &map);
}
gst_avi_mux_end_chunk (&bw, strf);
}
buffer = gst_byte_writer_reset_and_get_buffer (&bw);
/* ... but RIFF includes more than just header */
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READWRITE);
- size = GST_READ_UINT32_LE (bdata + 4);
+ gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
+ size = GST_READ_UINT32_LE (map.data + 4);
size += 8 + avimux->data_size + avimux->idx_size;
- GST_WRITE_UINT32_LE (bdata + 4, size);
+ GST_WRITE_UINT32_LE (map.data + 4, size);
- GST_MEMDUMP_OBJECT (avimux, "avi header", bdata, bsize);
- gst_buffer_unmap (buffer, bdata, bsize);
+ GST_MEMDUMP_OBJECT (avimux, "avi header", map.data, map.size);
+ gst_buffer_unmap (buffer, &map);
return buffer;
}
gst_avi_mux_riff_get_avix_header (guint32 datax_size)
{
GstBuffer *buffer;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
buffer = gst_buffer_new_and_alloc (24);
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata + 0, "RIFF", 4);
- GST_WRITE_UINT32_LE (bdata + 4, datax_size + 3 * 4);
- memcpy (bdata + 8, "AVIX", 4);
- memcpy (bdata + 12, "LIST", 4);
- GST_WRITE_UINT32_LE (bdata + 16, datax_size);
- memcpy (bdata + 20, "movi", 4);
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_map (buffer, &map, GST_MAP_WRITE);
+ memcpy (map.data + 0, "RIFF", 4);
+ GST_WRITE_UINT32_LE (map.data + 4, datax_size + 3 * 4);
+ memcpy (map.data + 8, "AVIX", 4);
+ memcpy (map.data + 12, "LIST", 4);
+ GST_WRITE_UINT32_LE (map.data + 16, datax_size);
+ memcpy (map.data + 20, "movi", 4);
+ gst_buffer_unmap (buffer, &map);
return buffer;
}
gst_avi_mux_riff_get_header (GstAviPad * avipad, guint32 video_frame_size)
{
GstBuffer *buffer;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
buffer = gst_buffer_new_and_alloc (8);
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata + 0, avipad->tag, 4);
- GST_WRITE_UINT32_LE (bdata + 4, video_frame_size);
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_map (buffer, &map, GST_MAP_WRITE);
+ memcpy (map.data + 0, avipad->tag, 4);
+ GST_WRITE_UINT32_LE (map.data + 4, video_frame_size);
+ gst_buffer_unmap (buffer, &map);
return buffer;
}
guint32 size, entry_count;
gboolean is_pcm = FALSE;
guint32 pcm_samples = 0;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
/* check if it is pcm */
if (avipad && !avipad->is_video) {
/* allocate the maximum possible */
buffer = gst_buffer_new_and_alloc (32 + 8 * avimux->idx_index);
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_WRITE);
- data = bdata;
+ gst_buffer_map (buffer, &map, GST_MAP_WRITE);
+ data = map.data;
/* general index chunk info */
- memcpy (bdata + 0, chunk, 4); /* chunk id */
- GST_WRITE_UINT32_LE (bdata + 4, 0); /* chunk size; fill later */
- GST_WRITE_UINT16_LE (bdata + 8, 2); /* index entry is 2 words */
- bdata[10] = 0; /* index subtype */
- bdata[11] = GST_AVI_INDEX_OF_CHUNKS; /* index type: AVI_INDEX_OF_CHUNKS */
- GST_WRITE_UINT32_LE (bdata + 12, 0); /* entries in use; fill later */
- memcpy (bdata + 16, code, 4); /* stream to which index refers */
- GST_WRITE_UINT64_LE (bdata + 20, avimux->avix_start); /* base offset */
- GST_WRITE_UINT32_LE (bdata + 28, 0); /* reserved */
- bdata += 32;
+ memcpy (map.data + 0, chunk, 4); /* chunk id */
+ GST_WRITE_UINT32_LE (map.data + 4, 0); /* chunk size; fill later */
+ GST_WRITE_UINT16_LE (map.data + 8, 2); /* index entry is 2 words */
+ map.data[10] = 0; /* index subtype */
+ map.data[11] = GST_AVI_INDEX_OF_CHUNKS; /* index type: AVI_INDEX_OF_CHUNKS */
+ GST_WRITE_UINT32_LE (map.data + 12, 0); /* entries in use; fill later */
+ memcpy (map.data + 16, code, 4); /* stream to which index refers */
+ GST_WRITE_UINT64_LE (map.data + 20, avimux->avix_start); /* base offset */
+ GST_WRITE_UINT32_LE (map.data + 28, 0); /* reserved */
+ map.data += 32;
/* now the actual index entries */
i = avimux->idx_index;
while (i > 0) {
if (memcmp (&entry->id, code, 4) == 0) {
/* enter relative offset to the data (!) */
- GST_WRITE_UINT32_LE (bdata, GUINT32_FROM_LE (entry->offset) + 8);
+ GST_WRITE_UINT32_LE (map.data, GUINT32_FROM_LE (entry->offset) + 8);
/* msb is set if not (!) keyframe */
- GST_WRITE_UINT32_LE (bdata + 4, GUINT32_FROM_LE (entry->size)
+ GST_WRITE_UINT32_LE (map.data + 4, GUINT32_FROM_LE (entry->size)
| (GUINT32_FROM_LE (entry->flags)
& GST_RIFF_IF_KEYFRAME ? 0 : 1U << 31));
- bdata += 8;
+ map.data += 8;
}
i--;
entry++;
}
/* ok, now we know the size and no of entries, fill in where needed */
- size = bdata - data;
+ size = map.data - data;
GST_WRITE_UINT32_LE (data + 4, size - 8);
entry_count = (size - 32) / 8;
GST_WRITE_UINT32_LE (data + 12, entry_count);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
+ gst_buffer_resize (buffer, 0, size);
/* send */
if ((res = gst_pad_push (avimux->srcpad, buffer)) != GST_FLOW_OK)
{
GstFlowReturn res;
GstBuffer *buffer;
- guint8 *buffdata;
- gsize buffsize;
+ GstMapInfo map;
+ guint8 *data;
+ gsize size;
buffer = gst_buffer_new_and_alloc (8);
- buffdata = gst_buffer_map (buffer, &buffsize, NULL, GST_MAP_WRITE);
- memcpy (buffdata + 0, "idx1", 4);
- GST_WRITE_UINT32_LE (buffdata + 4,
+ gst_buffer_map (buffer, &map, GST_MAP_WRITE);
+ memcpy (map.data + 0, "idx1", 4);
+ GST_WRITE_UINT32_LE (map.data + 4,
avimux->idx_index * sizeof (gst_riff_index_entry));
- gst_buffer_unmap (buffer, buffdata, buffsize);
+ gst_buffer_unmap (buffer, &map);
res = gst_pad_push (avimux->srcpad, buffer);
if (res != GST_FLOW_OK)
buffer = gst_buffer_new ();
- buffsize = avimux->idx_index * sizeof (gst_riff_index_entry);
- buffdata = (guint8 *) avimux->idx;
+ size = avimux->idx_index * sizeof (gst_riff_index_entry);
+ data = (guint8 *) avimux->idx;
avimux->idx = NULL; /* will be free()'ed by gst_buffer_unref() */
gst_buffer_take_memory (buffer, -1,
- gst_memory_new_wrapped (0, buffdata, g_free, buffsize, 0, buffsize));
+ gst_memory_new_wrapped (0, data, g_free, size, 0, size));
- avimux->total_data += buffsize + 8;
+ avimux->total_data += size + 8;
res = gst_pad_push (avimux->srcpad, buffer);
if (res != GST_FLOW_OK)
gst_avi_mux_send_pad_data (GstAviMux * avimux, gulong num_bytes)
{
GstBuffer *buffer;
- guint8 *bdata;
- gsize bsize;
buffer = gst_buffer_new_and_alloc (num_bytes);
-
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_WRITE);
- memset (bdata, 0, num_bytes);
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_memset (buffer, 0, 0, num_bytes);
return gst_pad_push (avimux->srcpad, buffer);
}
{
const gchar *input_enc = NULL;
GstBuffer *ret = NULL;
- gchar *data, *bdata;
- gsize bsize;
+ gchar *data;
+ GstMapInfo map;
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
- data = bdata + offset;
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = (gchar *) (map.data + offset);
if (len >= (3 + 1) && IS_BOM_UTF8 (data) &&
g_utf8_validate (data + 3, len - 3, NULL)) {
}
done:
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
static GstFlowReturn
gst_avi_subtitle_parse_gab2_chunk (GstAviSubtitle * sub, GstBuffer * buf)
{
- guint8 *data;
gchar *name_utf8;
guint name_length;
guint file_length;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
/* check the magic word "GAB2\0", and the next word must be 2 */
- if (size < 12 || memcmp (data, "GAB2\0\2\0", 5 + 2) != 0)
+ if (map.size < 12 || memcmp (map.data, "GAB2\0\2\0", 5 + 2) != 0)
goto wrong_magic_word;
/* read 'name' of subtitle */
- name_length = GST_READ_UINT32_LE (data + 5 + 2);
+ name_length = GST_READ_UINT32_LE (map.data + 5 + 2);
GST_LOG_OBJECT (sub, "length of name: %u", name_length);
- if (size <= 17 + name_length)
+ if (map.size <= 17 + name_length)
goto wrong_name_length;
- name_utf8 = g_convert ((gchar *) data + 11, name_length, "UTF-8", "UTF-16LE",
+ name_utf8 =
+ g_convert ((gchar *) map.data + 11, name_length, "UTF-8", "UTF-16LE",
NULL, NULL, NULL);
if (name_utf8) {
}
/* next word must be 4 */
- if (GST_READ_UINT16_LE (data + 11 + name_length) != 0x4)
+ if (GST_READ_UINT16_LE (map.data + 11 + name_length) != 0x4)
goto wrong_fixed_word_2;
- file_length = GST_READ_UINT32_LE (data + 13 + name_length);
+ file_length = GST_READ_UINT32_LE (map.data + 13 + name_length);
GST_LOG_OBJECT (sub, "length srt/ssa file: %u", file_length);
- if (size < (17 + name_length + file_length))
+ if (map.size < (17 + name_length + file_length))
goto wrong_total_length;
/* store this, so we can send it again after a seek; note that we shouldn't
if (sub->subfile == NULL)
goto extract_failed;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
wrong_magic_word:
{
GST_ELEMENT_ERROR (sub, STREAM, DECODE, (NULL), ("Wrong magic word"));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
wrong_name_length:
{
GST_ELEMENT_ERROR (sub, STREAM, DECODE, (NULL),
- ("name doesn't fit in buffer (%" G_GSIZE_FORMAT " < %d)", size,
+ ("name doesn't fit in buffer (%" G_GSIZE_FORMAT " < %d)", map.size,
17 + name_length));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
wrong_fixed_word_2:
{
GST_ELEMENT_ERROR (sub, STREAM, DECODE, (NULL),
("wrong fixed word: expected %u, got %u", 4,
- GST_READ_UINT16_LE (data + 11 + name_length)));
- gst_buffer_unmap (buf, data, size);
+ GST_READ_UINT16_LE (map.data + 11 + name_length)));
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
wrong_total_length:
{
GST_ELEMENT_ERROR (sub, STREAM, DECODE, (NULL),
("buffer size is wrong: need %d bytes, have %" G_GSIZE_FORMAT " bytes",
- 17 + name_length + file_length, size));
- gst_buffer_unmap (buf, data, size);
+ 17 + name_length + file_length, map.size));
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
extract_failed:
{
GST_ELEMENT_ERROR (sub, STREAM, DECODE, (NULL),
("could not extract subtitles"));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_ERROR;
}
}
{
GstFlowReturn ret = GST_FLOW_OK;
GstCutter *filter;
+ GstMapInfo map;
gint16 *in_data;
gint bpf, rate;
gsize in_size;
bpf = GST_AUDIO_INFO_BPF (&filter->info);
rate = GST_AUDIO_INFO_RATE (&filter->info);
- in_data = gst_buffer_map (buf, &in_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ in_data = (gint16 *) map.data;
+ in_size = map.size;
GST_LOG_OBJECT (filter, "length of prerec buffer: %" GST_TIME_FORMAT,
GST_TIME_ARGS (filter->pre_run_length));
break;
}
- gst_buffer_unmap (buf, in_data, in_size);
+ gst_buffer_unmap (buf, &map);
filter->silent_prev = filter->silent;
gst_break_my_data_transform_ip (GstBaseTransform * trans, GstBuffer * buf)
{
GstBreakMyData *bmd = GST_BREAK_MY_DATA (trans);
- guint8 *data;
- gsize i, size;
+ GstMapInfo map;
+ gsize i;
g_return_val_if_fail (gst_buffer_is_writable (buf), GST_FLOW_ERROR);
i = 0;
}
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
+ gst_buffer_map (buf, &map, GST_MAP_READWRITE);
GST_LOG_OBJECT (bmd,
"got buffer %p (size %" G_GSIZE_FORMAT ", timestamp %" G_GUINT64_FORMAT
- ", offset %" G_GUINT64_FORMAT "", buf, size, GST_BUFFER_TIMESTAMP (buf),
- GST_BUFFER_OFFSET (buf));
+ ", offset %" G_GUINT64_FORMAT "", buf, map.size,
+ GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_OFFSET (buf));
- for (; i < size; i++) {
+ for (; i < map.size; i++) {
if (g_rand_double_range (bmd->rand, 0, 1.0) <= bmd->probability) {
guint8 new;
}
GST_INFO_OBJECT (bmd,
"changing byte %" G_GSIZE_FORMAT " from 0x%02X to 0x%02X", i,
- (guint) GST_READ_UINT8 (data + i), (guint) ((guint8) new));
- data[i] = new;
+ (guint) GST_READ_UINT8 (map.data + i), (guint) ((guint8) new));
+ map.data[i] = new;
}
}
/* don't overflow */
- bmd->skipped += MIN (G_MAXUINT - bmd->skipped, size);
+ bmd->skipped += MIN (G_MAXUINT - bmd->skipped, map.size);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
GST_OBJECT_UNLOCK (bmd);
static void
md5_add (gpointer checksum, GstBuffer * buffer)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- g_checksum_update (checksum, data, size);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ g_checksum_update (checksum, map.data, map.size);
+ gst_buffer_unmap (buffer, &map);
}
static gboolean
GstAudioFilter *filter = GST_AUDIO_FILTER (btrans);
GstIirEqualizer *equ = GST_IIR_EQUALIZER (btrans);
GstClockTime timestamp;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
gint channels = GST_AUDIO_FILTER_CHANNELS (filter);
if (G_UNLIKELY (channels < 1 || equ->process == NULL))
}
BANDS_UNLOCK (equ);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
- equ->process (equ, data, size, channels);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ equ->process (equ, map.data, map.size, channels);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
GstFlowReturn ret = GST_FLOW_OK;
GstByteReader reader;
guint8 type = 0;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
g_return_val_if_fail (gst_buffer_get_size (buffer) >= 7, GST_FLOW_ERROR);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
- gst_byte_reader_init (&reader, data, size);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ gst_byte_reader_init (&reader, map.data, map.size);
gst_byte_reader_skip (&reader, 7);
}
cleanup:
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
break;
case 10:
{
- guint8 *data = NULL;
- gsize size;
-
- if (demux->audio_codec_data)
- data = gst_buffer_map (demux->audio_codec_data, &size, NULL,
- GST_MAP_READ);
- /* use codec-data to extract and verify samplerate */
- if (demux->audio_codec_data && size >= 2) {
- gint freq_index;
-
- freq_index = GST_READ_UINT16_BE (data);
- freq_index = (freq_index & 0x0780) >> 7;
- adjusted_rate =
- gst_codec_utils_aac_get_sample_rate_from_index (freq_index);
-
- if (adjusted_rate && (rate != adjusted_rate)) {
- GST_LOG_OBJECT (demux, "Ajusting AAC sample rate %d -> %d", rate,
- adjusted_rate);
- } else {
- adjusted_rate = rate;
+ if (demux->audio_codec_data) {
+ GstMapInfo map;
+
+ gst_buffer_map (demux->audio_codec_data, &map, GST_MAP_READ);
+
+ /* use codec-data to extract and verify samplerate */
+ if (map.size >= 2) {
+ gint freq_index;
+
+ freq_index = GST_READ_UINT16_BE (map.data);
+ freq_index = (freq_index & 0x0780) >> 7;
+ adjusted_rate =
+ gst_codec_utils_aac_get_sample_rate_from_index (freq_index);
+
+ if (adjusted_rate && (rate != adjusted_rate)) {
+ GST_LOG_OBJECT (demux, "Ajusting AAC sample rate %d -> %d", rate,
+ adjusted_rate);
+ } else {
+ adjusted_rate = rate;
+ }
}
+ gst_buffer_unmap (demux->audio_codec_data, &map);
}
- if (data)
- gst_buffer_unmap (demux->audio_codec_data, data, -1);
+
caps = gst_caps_new_simple ("audio/mpeg",
"mpegversion", G_TYPE_INT, 4, "framed", G_TYPE_BOOLEAN, TRUE,
"stream-format", G_TYPE_STRING, "raw", NULL);
guint32 pts = 0, codec_tag = 0, rate = 5512, width = 8, channels = 1;
guint32 codec_data = 0, pts_ext = 0;
guint8 flags = 0;
- guint8 *data;
+ GstMapInfo map;
GstBuffer *outbuf;
- gsize size;
+ guint8 *data;
GST_LOG_OBJECT (demux, "parsing an audio tag");
return GST_FLOW_ERROR;
}
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
/* Grab information about audio tag */
pts = GST_READ_UINT24_BE (data);
flags = GST_READ_UINT8 (data + 7);
/* Silently skip buffers with no data */
- if (size == 11)
+ if (map.size == 11)
goto beach;
/* Channels */
demux->audio_linked = TRUE;
beach:
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
guint32 pts = 0, codec_data = 1, pts_ext = 0;
gboolean keyframe = FALSE;
guint8 flags = 0, codec_tag = 0;
- guint8 *data;
GstBuffer *outbuf;
- gsize size;
+ GstMapInfo map;
+ guint8 *data;
g_return_val_if_fail (gst_buffer_get_size (buffer) == demux->tag_size,
GST_FLOW_ERROR);
return GST_FLOW_ERROR;
}
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
/* Grab information about video tag */
pts = GST_READ_UINT24_BE (data);
demux->video_linked = TRUE;
beach:
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
guint8 type;
gboolean keyframe = TRUE;
GstClockTime ret = GST_CLOCK_TIME_NONE;
- guint8 *data, *bdata;
+ GstMapInfo map;
+ guint8 *data;
gsize size;
g_return_val_if_fail (gst_buffer_get_size (buffer) >= 12,
GST_CLOCK_TIME_NONE);
- data = bdata = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
type = data[0];
demux->duration = ret;
exit:
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
{
GstFlowReturn ret = GST_FLOW_OK;
guint8 tag_type = 0;
- guint8 *data;
+ GstMapInfo map;
g_return_val_if_fail (gst_buffer_get_size (buffer) >= 4, GST_FLOW_ERROR);
- data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- tag_type = data[0];
+ tag_type = map.data[0];
switch (tag_type) {
case 9:
/* Tag size is 1 byte of type + 3 bytes of size + 7 bytes + tag data size +
* 4 bytes of previous tag size */
- demux->tag_data_size = GST_READ_UINT24_BE (data + 1);
+ demux->tag_data_size = GST_READ_UINT24_BE (map.data + 1);
demux->tag_size = demux->tag_data_size + 11;
GST_LOG_OBJECT (demux, "tag data size is %" G_GUINT64_FORMAT,
demux->tag_data_size);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
gst_flv_demux_parse_header (GstFlvDemux * demux, GstBuffer * buffer)
{
GstFlowReturn ret = GST_FLOW_OK;
- guint8 *data;
+ GstMapInfo map;
g_return_val_if_fail (gst_buffer_get_size (buffer) >= 9, GST_FLOW_ERROR);
- data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
/* Check for the FLV tag */
- if (data[0] == 'F' && data[1] == 'L' && data[2] == 'V') {
+ if (map.data[0] == 'F' && map.data[1] == 'L' && map.data[2] == 'V') {
GST_DEBUG_OBJECT (demux, "FLV header detected");
} else {
if (G_UNLIKELY (demux->strict)) {
/* Now look at audio/video flags */
{
- guint8 flags = data[4];
+ guint8 flags = map.data[4];
demux->has_video = demux->has_audio = FALSE;
demux->need_header = FALSE;
beach:
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return ret;
}
gint64 ret = 0, offset;
size_t tag_size, size;
GstBuffer *buffer = NULL;
- guint8 *data;
+ GstMapInfo map;
if (!gst_pad_peer_query_duration (demux->sinkpad, GST_FORMAT_BYTES, &offset))
goto exit;
4, &buffer))
goto exit;
- data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_READ);
- tag_size = GST_READ_UINT32_BE (data);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ tag_size = GST_READ_UINT32_BE (map.data);
+ gst_buffer_unmap (buffer, &map);
GST_DEBUG_OBJECT (demux, "last tag size: %" G_GSIZE_FORMAT, tag_size);
gst_buffer_unref (buffer);
buffer = NULL;
goto exit;
/* a consistency check */
- data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_READ);
- size = GST_READ_UINT24_BE (data + 1);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ size = GST_READ_UINT24_BE (map.data + 1);
if (size != tag_size - 11) {
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
GST_DEBUG_OBJECT (demux,
"tag size %" G_GSIZE_FORMAT ", expected %" G_GSIZE_FORMAT
", corrupt or truncated file", size, tag_size - 11);
gst_flv_demux_parse_tag_timestamp (demux, FALSE, buffer, &size);
/* maybe get some more metadata */
- if (data[0] == 18) {
- gst_buffer_unmap (buffer, data, -1);
+ if (map.data[0] == 18) {
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
buffer = NULL;
GST_DEBUG_OBJECT (demux, "script tag, pulling it to parse");
tag_size, &buffer))
gst_flv_demux_parse_tag_script (demux, buffer);
} else {
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
}
exit:
{
const GstTagList *tags;
GstBuffer *script_tag, *tmp;
+ GstMapInfo map;
guint8 *data;
gint i, n_tags, tags_written = 0;
if (!mux->streamable && mux->duration != GST_CLOCK_TIME_NONE) {
gdouble d;
+ GstMapInfo map;
+
d = gst_guint64_to_gdouble (mux->duration);
d /= (gdouble) GST_SECOND;
GST_DEBUG_OBJECT (mux, "determined the duration to be %f", d);
- data = gst_buffer_map (script_tag, NULL, NULL, GST_MAP_WRITE);
- GST_WRITE_DOUBLE_BE (data + 29 + 2 + 8 + 1, d);
- gst_buffer_unmap (script_tag, data, -1);
+ gst_buffer_map (script_tag, &map, GST_MAP_WRITE);
+ GST_WRITE_DOUBLE_BE (map.data + 29 + 2 + 8 + 1, d);
+ gst_buffer_unmap (script_tag, &map);
}
if (mux->have_video) {
GST_WRITE_UINT32_BE (data, gst_buffer_get_size (script_tag));
script_tag = gst_buffer_join (script_tag, tmp);
- data = gst_buffer_map (script_tag, NULL, NULL, GST_MAP_WRITE);
- data[1] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 16) & 0xff;
- data[2] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 8) & 0xff;
- data[3] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 0) & 0xff;
+ gst_buffer_map (script_tag, &map, GST_MAP_WRITE);
+ map.data[1] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 16) & 0xff;
+ map.data[2] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 8) & 0xff;
+ map.data[3] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 0) & 0xff;
- GST_WRITE_UINT32_BE (data + 11 + 13 + 1, tags_written);
- gst_buffer_unmap (script_tag, data, -1);
+ GST_WRITE_UINT32_BE (map.data + 11 + 13 + 1, tags_written);
+ gst_buffer_unmap (script_tag, &map);
exit:
return script_tag;
GstFlvPad * cpad, gboolean is_codec_data)
{
GstBuffer *tag;
- guint8 *data;
+ GstMapInfo map;
guint size;
guint32 timestamp =
(GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) ? GST_BUFFER_TIMESTAMP (buffer) /
GST_MSECOND : cpad->last_timestamp / GST_MSECOND;
- guint8 *bdata;
+ guint8 *data, *bdata;
gsize bsize;
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ bdata = map.data;
+ bsize = map.size;
size = 11;
if (cpad->video) {
}
}
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
GST_WRITE_UINT32_BE (data + size - 4, size - 4);
return GST_TAG_DEMUX_RESULT_BROKEN_TAG;
}
} else {
- guint8 *data;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_READ);
- *tags = gst_tag_list_new_from_id3v1 (data);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ *tags = gst_tag_list_new_from_id3v1 (map.data);
+ gst_buffer_unmap (buffer, &map);
if (G_UNLIKELY (*tags == NULL))
return GST_TAG_DEMUX_RESULT_BROKEN_TAG;
guint64 size = 0;
if (prefix) {
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
- bdata = gst_buffer_map (prefix, &bsize, NULL, GST_MAP_READ);
- if (fwrite (bdata, 1, bsize, f) != bsize) {
- gst_buffer_unmap (prefix, bdata, bsize);
+ gst_buffer_map (prefix, &map, GST_MAP_READ);
+ if (fwrite (map.data, 1, map.size, f) != map.size) {
+ gst_buffer_unmap (prefix, &map);
return FALSE;
}
- gst_buffer_unmap (prefix, bdata, bsize);
+ gst_buffer_unmap (prefix, &map);
}
if (!atom_ftyp_copy_data (ftyp, &data, &size, &offset)) {
return FALSE;
GstQTMux * qtmux)
{
GstBuffer *newbuf;
- guint8 *data;
+ GstMapInfo map;
gsize size;
GST_LOG_OBJECT (qtmux, "Preparing jpc buffer");
newbuf = gst_buffer_new_and_alloc (size + 8);
gst_buffer_copy_into (newbuf, buf, GST_BUFFER_COPY_ALL, 8, size);
- data = gst_buffer_map (newbuf, &size, NULL, GST_MAP_WRITE);
- GST_WRITE_UINT32_BE (data, size);
- GST_WRITE_UINT32_LE (data + 4, FOURCC_jp2c);
+ gst_buffer_map (newbuf, &map, GST_MAP_WRITE);
+ GST_WRITE_UINT32_BE (map.data, map.size);
+ GST_WRITE_UINT32_LE (map.data + 4, FOURCC_jp2c);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return newbuf;
GstCaps *caps;
GstStructure *structure;
gint flags = 0;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_BUFFER);
goto done;
}
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT
- " -> image size %" G_GSIZE_FORMAT "", GST_FOURCC_ARGS (fourcc), size);
- atom_moov_add_tag (qtmux->moov, fourcc, flags, data, size);
- gst_buffer_unmap (buf, data, size);
+ " -> image size %" G_GSIZE_FORMAT "", GST_FOURCC_ARGS (fourcc), map.size);
+ atom_moov_add_tag (qtmux->moov, fourcc, flags, map.data, map.size);
+ gst_buffer_unmap (buf, &map);
done:
g_value_unset (&value);
}
if (buf && (caps = NULL /*gst_buffer_get_caps (buf) */ )) {
GstStructure *s;
const gchar *style = NULL;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
GST_DEBUG_OBJECT (qtmux,
"Found private tag %d/%d; size %" G_GSIZE_FORMAT ", caps %"
- GST_PTR_FORMAT, i, num_tags, size, caps);
+ GST_PTR_FORMAT, i, num_tags, map.size, caps);
s = gst_caps_get_structure (caps, 0);
if (s && (style = gst_structure_get_string (s, "style"))) {
/* try to prevent some style tag ending up into another variant
(strcmp (style, "iso") == 0 &&
qtmux_klass->format == GST_QT_MUX_FORMAT_3GP)) {
GST_DEBUG_OBJECT (qtmux, "Adding private tag");
- atom_moov_add_blob_tag (qtmux->moov, data, size);
+ atom_moov_add_blob_tag (qtmux->moov, map.data, map.size);
}
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_caps_unref (caps);
}
}
GST_LOG_OBJECT (qtmux, "sending buffer size %" G_GSIZE_FORMAT, size);
if (mind_fast && qtmux->fast_start_file) {
+ GstMapInfo map;
gint ret;
- guint8 *data;
GST_LOG_OBJECT (qtmux, "to temporary file");
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- ret = fwrite (data, sizeof (guint8), size, qtmux->fast_start_file);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ ret = fwrite (map.data, sizeof (guint8), map.size, qtmux->fast_start_file);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
if (ret != size)
goto write_error;
GST_DEBUG_OBJECT (qtmux, "Sending buffered data");
while (ret == GST_FLOW_OK) {
const int bufsize = 4096;
- guint8 *data;
+ GstMapInfo map;
gsize size;
buf = gst_buffer_new_and_alloc (bufsize);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
- size = fread (data, sizeof (guint8), bufsize, qtmux->fast_start_file);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ size = fread (map.data, sizeof (guint8), bufsize, qtmux->fast_start_file);
if (size == 0) {
- gst_buffer_unmap (buf, data, -1);
+ gst_buffer_unmap (buf, &map);
break;
}
- gst_buffer_unmap (buf, data, size);
- GST_LOG_OBJECT (qtmux, "Pushing buffered buffer of size %d", (gint) size);
+ GST_LOG_OBJECT (qtmux, "Pushing buffered buffer of size %d",
+ (gint) map.size);
+ gst_buffer_unmap (buf, &map);
ret = gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);
buf = NULL;
}
GstBuffer *buf;
gboolean large_file;
GstSegment segment;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
large_file = (mdat_size > MDAT_LARGE_FILE_LIMIT);
if (large_file) {
buf = gst_buffer_new_and_alloc (sizeof (guint64));
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
- GST_WRITE_UINT64_BE (data, mdat_size + 16);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ GST_WRITE_UINT64_BE (map.data, mdat_size + 16);
} else {
buf = gst_buffer_new_and_alloc (16);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
- GST_WRITE_UINT32_BE (data, 8);
- GST_WRITE_UINT32_LE (data + 4, FOURCC_free);
- GST_WRITE_UINT32_BE (data + 8, mdat_size + 8);
- GST_WRITE_UINT32_LE (data + 12, FOURCC_mdat);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ GST_WRITE_UINT32_BE (map.data, 8);
+ GST_WRITE_UINT32_LE (map.data + 4, FOURCC_free);
+ GST_WRITE_UINT32_BE (map.data + 8, mdat_size + 8);
+ GST_WRITE_UINT32_LE (map.data + 12, FOURCC_mdat);
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);
}
} else if (strcmp (mimetype, "audio/x-alac") == 0) {
GstBuffer *codec_config;
gint len;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
entry.fourcc = FOURCC_alac;
- data = gst_buffer_map ((GstBuffer *) codec_data, &size, NULL, GST_MAP_READ);
+ gst_buffer_map ((GstBuffer *) codec_data, &map, GST_MAP_READ);
/* let's check if codec data already comes with 'alac' atom prefix */
- if (!codec_data || (len = size) < 28) {
+ if (!codec_data || (len = map.size) < 28) {
GST_DEBUG_OBJECT (qtmux, "broken caps, codec data missing");
- gst_buffer_unmap ((GstBuffer *) codec_data, data, size);
+ gst_buffer_unmap ((GstBuffer *) codec_data, &map);
goto refuse_caps;
}
- if (GST_READ_UINT32_LE (data + 4) == FOURCC_alac) {
+ if (GST_READ_UINT32_LE (map.data + 4) == FOURCC_alac) {
len -= 8;
codec_config =
gst_buffer_copy_region ((GstBuffer *) codec_data, 0, 8, len);
} else {
codec_config = gst_buffer_ref ((GstBuffer *) codec_data);
}
- gst_buffer_unmap ((GstBuffer *) codec_data, data, size);
+ gst_buffer_unmap ((GstBuffer *) codec_data, &map);
if (len != 28) {
/* does not look good, but perhaps some trailing unneeded stuff */
GST_WARNING_OBJECT (qtmux, "unexpected codec-data size, possibly broken");
else
ext_atom = build_codec_data_extension (FOURCC_alac, codec_config);
/* set some more info */
- data = gst_buffer_map (codec_config, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (codec_config, &map, GST_MAP_READ);
entry.bytes_per_sample = 2;
- entry.samples_per_packet = GST_READ_UINT32_BE (data + 4);
- gst_buffer_unmap (codec_config, data, size);
+ entry.samples_per_packet = GST_READ_UINT32_BE (map.data + 4);
+ gst_buffer_unmap (codec_config, &map);
gst_buffer_unref (codec_config);
}
}
case GST_QT_MUX_FORMAT_MJ2:
{
- guint8 *bdata;
-
major = FOURCC_mjp2;
comp = mjp2_brands;
version = 0;
prefix = gst_buffer_new_and_alloc (sizeof (mjp2_prefix));
- bdata = gst_buffer_map (prefix, NULL, NULL, GST_MAP_WRITE);
- memcpy (bdata, mjp2_prefix, sizeof (mjp2_prefix));
- gst_buffer_unmap (prefix, bdata, -1);
+ gst_buffer_fill (prefix, 0, mjp2_prefix, sizeof (mjp2_prefix));
break;
}
default:
GstBuffer *buf;
gint size;
GstCaps *caps;
- guint8 *bdata;
GST_DEBUG_OBJECT (rtpxqtdepay, "found avcC codec_data in sd, %u",
chlen);
size = len - 8;
buf = gst_buffer_new_and_alloc (size);
- bdata = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
- memcpy (bdata, data + 8, size);
- gst_buffer_unmap (buf, bdata, -1);
+ gst_buffer_fill (buf, 0, data + 8, size);
caps = gst_caps_new_simple ("video/x-h264",
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
guint8 *payload;
guint8 ver, pck;
gboolean s, q, l, d;
- guint8 *bdata;
- gsize bsize;
payload_len = gst_rtp_buffer_get_payload_len (&rtp);
payload = gst_rtp_buffer_get_payload (&rtp);
{
/* multiple samples per packet. */
outbuf = gst_buffer_new_and_alloc (payload_len);
- bdata = gst_buffer_map (outbuf, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata, payload, payload_len);
- gst_buffer_unmap (outbuf, bdata, bsize);
+ gst_buffer_fill (outbuf, 0, payload, payload_len);
goto done;
}
slen = payload_len;
outbuf = gst_buffer_new_and_alloc (slen);
- bdata = gst_buffer_map (outbuf, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata, payload, slen);
- gst_buffer_unmap (outbuf, bdata, bsize);
+ gst_buffer_fill (outbuf, 0, payload, slen);
if (!s)
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
{
/* one sample per packet, use adapter to combine based on marker bit. */
outbuf = gst_buffer_new_and_alloc (payload_len);
- bdata = gst_buffer_map (outbuf, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata, payload, payload_len);
- gst_buffer_unmap (outbuf, bdata, bsize);
+ gst_buffer_fill (outbuf, 0, payload, payload_len);
gst_adapter_push (rtpxqtdepay->adapter, outbuf);
}
static void
-_gst_buffer_copy_into_mem (GstBuffer * dest, const guint8 * src,
- gsize offset, gsize size)
+_gst_buffer_copy_into_mem (GstBuffer * dest, gsize offset, const guint8 * src,
+ gsize size)
{
- guint8 *bdata;
gsize bsize;
g_return_if_fail (gst_buffer_is_writable (dest));
bsize = gst_buffer_get_size (dest);
g_return_if_fail (bsize >= offset + size);
- bdata = gst_buffer_map (dest, &bsize, NULL, GST_MAP_WRITE);
- memcpy (bdata + offset, src, size);
- gst_buffer_unmap (dest, bdata, bsize);
+ gst_buffer_fill (dest, offset, src, size);
}
static GstBuffer *
GstBuffer ** buf)
{
GstFlowReturn flow;
- guint8 *bdata;
+ GstMapInfo map;
gsize bsize;
if (G_UNLIKELY (size == 0)) {
if (ret != GST_FLOW_OK)
return ret;
- bdata = gst_buffer_map (tmp, &bsize, NULL, GST_MAP_READ);
- size = QT_UINT32 (bdata);
+ gst_buffer_map (tmp, &map, GST_MAP_READ);
+ size = QT_UINT32 (map.data);
GST_DEBUG_OBJECT (qtdemux, "size 0x%08" G_GINT64_MODIFIER "x", size);
- gst_buffer_unmap (tmp, bdata, bsize);
+ gst_buffer_unmap (tmp, &map);
gst_buffer_unref (tmp);
}
GST_DEBUG_OBJECT (qtdemux, "major brand: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (qtdemux->major_brand));
buf = qtdemux->comp_brands = gst_buffer_new_and_alloc (length - 16);
- _gst_buffer_copy_into_mem (buf, buffer + 16, 0, length - 16);
+ _gst_buffer_copy_into_mem (buf, 0, buffer + 16, length - 16);
}
}
GstBuffer *buf = NULL;
GstFlowReturn ret = GST_FLOW_OK;
guint64 cur_offset = qtdemux->offset;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, 16, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto beach;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- if (G_LIKELY (size >= 8))
- extract_initial_length_and_fourcc (data, size, &length, &fourcc);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (G_LIKELY (map.size >= 8))
+ extract_initial_length_and_fourcc (map.data, map.size, &length, &fourcc);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
/* maybe we already got most we needed, so only consider this eof */
ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, length, &moov);
if (ret != GST_FLOW_OK)
goto beach;
- data = gst_buffer_map (moov, &size, NULL, GST_MAP_READ);
- if (length != size) {
+ gst_buffer_map (moov, &map, GST_MAP_READ);
+ if (length != map.size) {
/* Some files have a 'moov' atom at the end of the file which contains
* a terminal 'free' atom where the body of the atom is missing.
* Check for, and permit, this special case.
*/
- if (size >= 8) {
- guint8 *final_data = data + (size - 8);
+ if (map.size >= 8) {
+ guint8 *final_data = map.data + (map.size - 8);
guint32 final_length = QT_UINT32 (final_data);
guint32 final_fourcc = QT_FOURCC (final_data + 4);
- gst_buffer_unmap (moov, data, size);
- if (final_fourcc == FOURCC_free && size + final_length - 8 == length) {
+ gst_buffer_unmap (moov, &map);
+ if (final_fourcc == FOURCC_free
+ && map.size + final_length - 8 == length) {
/* Ok, we've found that special case. Allocate a new buffer with
* that free atom actually present. */
GstBuffer *newmoov = gst_buffer_new_and_alloc (length);
- gst_buffer_copy_into (newmoov, moov, 0, 0, size);
- data = gst_buffer_map (newmoov, &size, NULL, GST_MAP_WRITE);
- memset (data + length - final_length + 8, 0, final_length - 8);
+ gst_buffer_copy_into (newmoov, moov, 0, 0, map.size);
+ gst_buffer_map (newmoov, &map, GST_MAP_WRITE);
+ memset (map.data + length - final_length + 8, 0, final_length - 8);
gst_buffer_unref (moov);
moov = newmoov;
}
}
}
- if (length != size) {
+ if (length != map.size) {
GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
(_("This file is incomplete and cannot be played.")),
("We got less than expected (received %" G_GSIZE_FORMAT
- ", wanted %u, offset %" G_GUINT64_FORMAT ")", size,
+ ", wanted %u, offset %" G_GUINT64_FORMAT ")", map.size,
(guint) length, cur_offset));
- gst_buffer_unmap (moov, data, size);
+ gst_buffer_unmap (moov, &map);
gst_buffer_unref (moov);
ret = GST_FLOW_ERROR;
goto beach;
}
qtdemux->offset += length;
- qtdemux_parse_moov (qtdemux, data, length);
+ qtdemux_parse_moov (qtdemux, map.data, length);
qtdemux_node_dump (qtdemux, qtdemux->moov_node);
qtdemux_parse_tree (qtdemux);
g_node_destroy (qtdemux->moov_node);
- gst_buffer_unmap (moov, data, size);
+ gst_buffer_unmap (moov, &map);
gst_buffer_unref (moov);
qtdemux->moov_node = NULL;
qtdemux->got_moov = TRUE;
if (ret != GST_FLOW_OK)
goto beach;
qtdemux->offset += length;
- data = gst_buffer_map (ftyp, &size, NULL, GST_MAP_READ);
- qtdemux_parse_ftyp (qtdemux, data, size);
- gst_buffer_unmap (ftyp, data, size);
+ gst_buffer_map (ftyp, &map, GST_MAP_READ);
+ qtdemux_parse_ftyp (qtdemux, map.data, map.size);
+ gst_buffer_unmap (ftyp, &map);
gst_buffer_unref (ftyp);
break;
}
if (ret != GST_FLOW_OK)
goto beach;
qtdemux->offset += length;
- data = gst_buffer_map (uuid, &size, NULL, GST_MAP_READ);
- qtdemux_parse_uuid (qtdemux, data, size);
- gst_buffer_unmap (uuid, data, size);
+ gst_buffer_map (uuid, &map, GST_MAP_READ);
+ qtdemux_parse_uuid (qtdemux, map.data, map.size);
+ gst_buffer_unmap (uuid, &map);
gst_buffer_unref (uuid);
break;
}
ret = gst_qtdemux_pull_atom (qtdemux, cur_offset, length, &unknown);
if (ret != GST_FLOW_OK)
goto beach;
- data = gst_buffer_map (unknown, &size, NULL, GST_MAP_READ);
- GST_MEMDUMP ("Unknown tag", data, size);
- gst_buffer_unmap (unknown, data, size);
+ gst_buffer_map (unknown, &map, GST_MAP_READ);
+ GST_MEMDUMP ("Unknown tag", map.data, map.size);
+ gst_buffer_unmap (unknown, &map);
gst_buffer_unref (unknown);
qtdemux->offset += length;
break;
gst_qtdemux_process_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream,
GstBuffer * buf)
{
- guint8 *data;
+ GstMapInfo map;
guint nsize = 0;
- gsize size;
gchar *str;
/* not many cases for now */
return buf;
}
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (G_LIKELY (size >= 2)) {
- nsize = GST_READ_UINT16_BE (data);
- nsize = MIN (nsize, size - 2);
+ if (G_LIKELY (map.size >= 2)) {
+ nsize = GST_READ_UINT16_BE (map.data);
+ nsize = MIN (nsize, map.size - 2);
}
GST_LOG_OBJECT (qtdemux, "3GPP timed text subtitle: %d/%" G_GSIZE_FORMAT "",
- nsize, size);
+ nsize, map.size);
/* takes care of UTF-8 validation or UTF-16 recognition,
* no other encoding expected */
- str = gst_tag_freeform_string_to_utf8 ((gchar *) data + 2, nsize, NULL);
- gst_buffer_unmap (buf, data, size);
+ str = gst_tag_freeform_string_to_utf8 ((gchar *) map.data + 2, nsize, NULL);
+ gst_buffer_unmap (buf, &map);
if (str) {
gst_buffer_unref (buf);
buf = _gst_buffer_new_wrapped (str, strlen (str), g_free);
if (G_UNLIKELY (stream->fourcc == FOURCC_rtsp)) {
gchar *url;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- url = g_strndup ((gchar *) bdata, bsize);
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ url = g_strndup ((gchar *) map.data, map.size);
+ gst_buffer_unmap (buf, &map);
if (url != NULL && strlen (url) != 0) {
/* we have RTSP redirect now */
gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
switch (type) {
case FOURCC_tCtH:
buffer = gst_buffer_new_and_alloc (size);
- _gst_buffer_copy_into_mem (buffer, buf, 0, size);
+ _gst_buffer_copy_into_mem (buffer, 0, buf, size);
stream->buffers = g_slist_append (stream->buffers, buffer);
GST_LOG_OBJECT (qtdemux, "parsing theora header");
break;
case FOURCC_tCt_:
buffer = gst_buffer_new_and_alloc (size);
- _gst_buffer_copy_into_mem (buffer, buf, 0, size);
+ _gst_buffer_copy_into_mem (buffer, 0, buf, size);
stream->buffers = g_slist_append (stream->buffers, buffer);
GST_LOG_OBJECT (qtdemux, "parsing theora comment");
break;
case FOURCC_tCtC:
buffer = gst_buffer_new_and_alloc (size);
- _gst_buffer_copy_into_mem (buffer, buf, 0, size);
+ _gst_buffer_copy_into_mem (buffer, 0, buf, size);
stream->buffers = g_slist_append (stream->buffers, buffer);
GST_LOG_OBJECT (qtdemux, "parsing theora codebook");
break;
G_GUINT64_FORMAT, GST_FOURCC_ARGS (fourcc), *offset);
while (TRUE) {
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
ret = gst_pad_pull_range (qtdemux->sinkpad, *offset, 16, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
gst_buffer_unref (buf);
goto locate_failed;
}
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- extract_initial_length_and_fourcc (bdata, 16, length, &lfourcc);
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ extract_initial_length_and_fourcc (map.data, 16, length, &lfourcc);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
if (G_UNLIKELY (*length == 0)) {
GstBuffer *buf = NULL;
GstFlowReturn ret = GST_FLOW_OK;
GstFlowReturn res = GST_FLOW_OK;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
offset = qtdemux->moof_offset;
GST_DEBUG_OBJECT (qtdemux, "next moof at offset %" G_GUINT64_FORMAT, offset);
ret = gst_qtdemux_pull_atom (qtdemux, offset, length, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto flow_failed;
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- if (!qtdemux_parse_moof (qtdemux, bdata, bsize, offset, NULL)) {
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ if (!qtdemux_parse_moof (qtdemux, map.data, map.size, offset, NULL)) {
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
goto parse_failed;
}
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
seqh_size = QT_UINT32 (data + 4);
if (seqh_size > 0) {
_seqh = gst_buffer_new_and_alloc (seqh_size);
- _gst_buffer_copy_into_mem (_seqh, data + 8, 0, seqh_size);
+ _gst_buffer_copy_into_mem (_seqh, 0, data + 8, seqh_size);
}
}
}
static const guint wb_bitrates[] = {
6600, 8850, 12650, 14250, 15850, 18250, 19850, 23050, 23850
};
- guint8 *data;
- gsize size, max_mode;
+ GstMapInfo map;
+ gsize max_mode;
guint16 mode_set;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (size != 0x11) {
- GST_DEBUG ("Atom should have size 0x11, not %" G_GSIZE_FORMAT, size);
+ if (map.size != 0x11) {
+ GST_DEBUG ("Atom should have size 0x11, not %" G_GSIZE_FORMAT, map.size);
goto bad_data;
}
- if (QT_FOURCC (data + 4) != GST_MAKE_FOURCC ('d', 'a', 'm', 'r')) {
+ if (QT_FOURCC (map.data + 4) != GST_MAKE_FOURCC ('d', 'a', 'm', 'r')) {
GST_DEBUG ("Unknown atom in %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (QT_UINT32 (data + 4)));
+ GST_FOURCC_ARGS (QT_UINT32 (map.data + 4)));
goto bad_data;
}
- mode_set = QT_UINT16 (data + 13);
+ mode_set = QT_UINT16 (map.data + 13);
if (mode_set == (wb ? AMR_WB_ALL_MODES : AMR_NB_ALL_MODES))
max_mode = 7 + (wb ? 1 : 0);
goto bad_data;
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return wb ? wb_bitrates[max_mode] : nb_bitrates[max_mode];
bad_data:
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return 0;
}
avc_data + 8 + 1, size - 1);
buf = gst_buffer_new_and_alloc (size);
- _gst_buffer_copy_into_mem (buf, avc_data + 0x8, 0, size);
+ _gst_buffer_copy_into_mem (buf, 0, avc_data + 0x8, size);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
if (len > 0x8) {
len -= 0x8;
buf = gst_buffer_new_and_alloc (len);
- _gst_buffer_copy_into_mem (buf, data + 8, 0, len);
+ _gst_buffer_copy_into_mem (buf, 0, data + 8, len);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
if (len > 0x8) {
len -= 0x8;
buf = gst_buffer_new_and_alloc (len);
- _gst_buffer_copy_into_mem (buf, data + 8, 0, len);
+ _gst_buffer_copy_into_mem (buf, 0, data + 8, len);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
GST_DEBUG_OBJECT (qtdemux, "found codec_data in stsd");
buf = gst_buffer_new_and_alloc (len);
- _gst_buffer_copy_into_mem (buf, stsd_data, 0, len);
+ _gst_buffer_copy_into_mem (buf, 0, stsd_data, len);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
break;
}
buf = gst_buffer_new_and_alloc (ovc1_len - 198);
- _gst_buffer_copy_into_mem (buf, ovc1_data + 198, 0, ovc1_len - 198);
+ _gst_buffer_copy_into_mem (buf, 0, ovc1_data + 198, ovc1_len - 198);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
}
wfex = (WAVEFORMATEX *) (owma_data + 36);
buf = gst_buffer_new_and_alloc (owma_len - 54);
- _gst_buffer_copy_into_mem (buf, owma_data + 54, 0, owma_len - 54);
+ _gst_buffer_copy_into_mem (buf, 0, owma_data + 54, owma_len - 54);
if (wfex->wFormatTag == 0x0161) {
codec_name = "Windows Media Audio";
version = 2;
headerlen -= 8;
headerbuf = gst_buffer_new_and_alloc (headerlen);
- _gst_buffer_copy_into_mem (headerbuf, waveheader, 0, headerlen);
+ _gst_buffer_copy_into_mem (headerbuf, 0, waveheader, headerlen);
if (gst_riff_parse_strf_auds (GST_ELEMENT_CAST (qtdemux),
headerbuf, &header, &extra)) {
if (len > 0x4C) {
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x4C);
- _gst_buffer_copy_into_mem (buf, stsd_data + 0x4C, 0, len - 0x4C);
+ _gst_buffer_copy_into_mem (buf, 0, stsd_data + 0x4C, len - 0x4C);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
/* codec-data contains alac atom size and prefix,
* ffmpeg likes it that way, not quite gst-ish though ...*/
buf = gst_buffer_new_and_alloc (len);
- _gst_buffer_copy_into_mem (buf, alac->data, 0, len);
+ _gst_buffer_copy_into_mem (buf, 0, alac->data, len);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x34);
guint bitrate;
- _gst_buffer_copy_into_mem (buf, stsd_data + 0x34, 0, len - 0x34);
+ _gst_buffer_copy_into_mem (buf, 0, stsd_data + 0x34, len - 0x34);
/* If we have enough data, let's try to get the 'damr' atom. See
* the 3GPP container spec (26.244) for more details. */
return ((qtdemux->major_brand & GST_MAKE_FOURCC (255, 255, 0, 0)) ==
GST_MAKE_FOURCC ('3', 'g', 0, 0));
} else if (qtdemux->comp_brands != NULL) {
+ GstMapInfo map;
guint8 *data;
gsize size;
gboolean res = FALSE;
- data = gst_buffer_map (qtdemux->comp_brands, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (qtdemux->comp_brands, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
while (size >= 4) {
res = res || ((QT_FOURCC (data) & GST_MAKE_FOURCC (255, 255, 0, 0)) ==
GST_MAKE_FOURCC ('3', 'g', 0, 0));
data += 4;
size -= 4;
}
- gst_buffer_unmap (qtdemux->comp_brands, data, size);
+ gst_buffer_unmap (qtdemux->comp_brands, &map);
return res;
} else {
return FALSE;
data = node->data;
len = QT_UINT32 (data);
buf = gst_buffer_new_and_alloc (len);
- _gst_buffer_copy_into_mem (buf, data, 0, len);
+ _gst_buffer_copy_into_mem (buf, 0, data, len);
/* heuristic to determine style of tag */
if (QT_FOURCC (data + 4) == FOURCC_____ ||
GstBuffer *buffer;
buffer = gst_buffer_new_and_alloc (data_len);
- _gst_buffer_copy_into_mem (buffer, data_ptr, 0, data_len);
+ _gst_buffer_copy_into_mem (buffer, 0, data_ptr, data_len);
GST_DEBUG_OBJECT (qtdemux, "setting codec_data from esds");
GST_MEMDUMP_OBJECT (qtdemux, "codec_data from esds", data_ptr, data_len);
gst_alaw_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstALawDec *alawdec;
+ GstMapInfo inmap, outmap;
gint16 *linear_data;
guint8 *alaw_data;
gsize alaw_size;
GST_LOG_OBJECT (alawdec, "buffer with ts=%" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
- alaw_data = gst_buffer_map (buffer, &alaw_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &inmap, GST_MAP_READ);
+ alaw_data = inmap.data;
+ alaw_size = inmap.size;
outbuf = gst_buffer_new_allocate (NULL, alaw_size, 0);
- linear_data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
+ linear_data = (gint16 *) outmap.data;
/* copy discont flag */
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
linear_data[i] = alaw_to_s16 (alaw_data[i]);
}
- gst_buffer_unmap (outbuf, linear_data, -1);
- gst_buffer_unmap (buffer, alaw_data, -1);
+ gst_buffer_unmap (outbuf, &outmap);
+ gst_buffer_unmap (buffer, &inmap);
gst_buffer_unref (buffer);
ret = gst_pad_push (alawdec->srcpad, outbuf);
gst_alaw_enc_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstALawEnc *alawenc;
+ GstMapInfo inmap, outmap;
gint16 *linear_data;
gsize linear_size;
guint8 *alaw_data;
if (G_UNLIKELY (alawenc->rate == 0 || alawenc->channels == 0))
goto not_negotiated;
- linear_data = gst_buffer_map (buffer, &linear_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &inmap, GST_MAP_READ);
+ linear_data = (gint16 *) inmap.data;
+ linear_size = inmap.size;
alaw_size = linear_size / 2;
GST_SECOND, alawenc->rate * alawenc->channels);
}
- alaw_data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
+ alaw_data = outmap.data;
+ alaw_size = outmap.size;
/* copy discont flag */
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
alaw_data[i] = s16_to_alaw (linear_data[i]);
}
- gst_buffer_unmap (outbuf, alaw_data, -1);
- gst_buffer_unmap (buffer, linear_data, -1);
+ gst_buffer_unmap (outbuf, &outmap);
+ gst_buffer_unmap (buffer, &inmap);
gst_buffer_unref (buffer);
ret = gst_pad_push (alawenc->srcpad, outbuf);
gst_mulawdec_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstMuLawDec *mulawdec;
+ GstMapInfo inmap, outmap;
gint16 *linear_data;
guint8 *mulaw_data;
gsize mulaw_size, linear_size;
if (G_UNLIKELY (mulawdec->rate == 0))
goto not_negotiated;
- mulaw_data = gst_buffer_map (buffer, &mulaw_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &inmap, GST_MAP_READ);
+ mulaw_data = inmap.data;
+ mulaw_size = inmap.size;
linear_size = mulaw_size * 2;
outbuf = gst_buffer_new_allocate (NULL, linear_size, 0);
- linear_data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
+ linear_data = (gint16 *) outmap.data;
/* copy discont flag */
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
mulaw_decode (mulaw_data, linear_data, mulaw_size);
- gst_buffer_unmap (outbuf, linear_data, -1);
- gst_buffer_unmap (buffer, mulaw_data, -1);
+ gst_buffer_unmap (outbuf, &outmap);
+ gst_buffer_unmap (buffer, &inmap);
gst_buffer_unref (buffer);
ret = gst_pad_push (mulawdec->srcpad, outbuf);
gst_mulawenc_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstMuLawEnc *mulawenc;
+ GstMapInfo inmap, outmap;
gint16 *linear_data;
gsize linear_size;
guint8 *mulaw_data;
if (!mulawenc->rate || !mulawenc->channels)
goto not_negotiated;
- linear_data = gst_buffer_map (buffer, &linear_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &inmap, GST_MAP_READ);
+ linear_data = (gint16 *) inmap.data;
+ linear_size = inmap.size;
mulaw_size = linear_size / 2;
GST_SECOND, mulawenc->rate * mulawenc->channels);
}
- mulaw_data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
+ mulaw_data = outmap.data;
/* copy discont flag */
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
mulaw_encode (linear_data, mulaw_data, mulaw_size);
- gst_buffer_unmap (outbuf, mulaw_data, -1);
- gst_buffer_unmap (buffer, linear_data, -1);
+ gst_buffer_unmap (outbuf, &outmap);
+ gst_buffer_unmap (buffer, &inmap);
gst_buffer_unref (buffer);
ret = gst_pad_push (mulawenc->srcpad, outbuf);
gst_level_transform_ip (GstBaseTransform * trans, GstBuffer * in)
{
GstLevel *filter;
- guint8 *in_data, *data;
+ GstMapInfo map;
+ guint8 *in_data;
gsize in_size;
gdouble CS;
guint i;
bps = GST_AUDIO_INFO_BPS (&filter->info);
rate = GST_AUDIO_INFO_RATE (&filter->info);
- in_data = data = gst_buffer_map (in, &in_size, NULL, GST_MAP_READ);
+ gst_buffer_map (in, &map, GST_MAP_READ);
+ in_data = map.data;
+ in_size = map.size;
+
num_int_samples = in_size / bps;
GST_LOG_OBJECT (filter, "analyzing %u sample frames at ts %" GST_TIME_FORMAT,
filter->num_frames = 0;
}
- gst_buffer_unmap (in, data, in_size);
+ gst_buffer_unmap (in, &map);
return GST_FLOW_OK;
}
guint64 offset)
{
GstEbmlMaster m;
- gsize buf_size;
g_return_if_fail (el);
g_return_if_fail (buf);
ebml->el = el;
ebml->offset = offset;
ebml->buf = buf;
- ebml->buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &ebml->map, GST_MAP_READ);
ebml->readers = g_array_sized_new (FALSE, FALSE, sizeof (GstEbmlMaster), 10);
m.offset = ebml->offset;
- gst_byte_reader_init (&m.br, ebml->buf_data, buf_size);
+ gst_byte_reader_init (&m.br, ebml->map.data, ebml->map.size);
g_array_append_val (ebml->readers, m);
}
g_array_free (ebml->readers, TRUE);
ebml->readers = NULL;
if (ebml->buf) {
- gst_buffer_unmap (ebml->buf, ebml->buf_data, -1);
+ gst_buffer_unmap (ebml->buf, &ebml->map);
gst_buffer_unref (ebml->buf);
}
ebml->buf = NULL;
GstElement *el;
GstBuffer *buf;
- gpointer buf_data;
guint64 offset;
+ GstMapInfo map;
GArray *readers;
} GstEbmlRead;
{
/* Create new buffer of size + ID + length */
GstBuffer *buf;
+ GstMapInfo map;
/* length, ID */
size += 12;
buf = gst_buffer_new_and_alloc (size);
GST_BUFFER_TIMESTAMP (buf) = ebml->timestamp;
- *data_out = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ /* FIXME unmap not possible */
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ *data_out = map.data;
return buf;
}
gst_ebml_write_element_push (GstEbmlWrite * ebml, GstBuffer * buf,
guint8 * buf_data, guint8 * buf_data_end)
{
+ GstMapInfo map;
guint data_size;
if (buf_data_end)
/* if there's no cache, then don't push it! */
if (ebml->writing_streamheader) {
- if (!buf_data)
- buf_data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ if (!buf_data) {
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ buf_data = map.data;
+ }
gst_byte_writer_put_data (ebml->streamheader, buf_data, data_size);
}
if (ebml->cache) {
- if (!buf_data)
- buf_data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ if (!buf_data) {
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ buf_data = map.data;
+ }
gst_byte_writer_put_data (ebml->cache, buf_data, data_size);
- gst_buffer_unmap (buf, buf_data, -1);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return;
}
if (buf_data)
- gst_buffer_unmap (buf, buf_data, -1);
+ gst_buffer_unmap (buf, &map);
if (ebml->last_write_result == GST_FLOW_OK) {
buf = gst_buffer_make_writable (buf);
if (demux->common.cached_buffer) {
if (demux->common.cached_data) {
- gst_buffer_unmap (demux->common.cached_buffer,
- demux->common.cached_data, -1);
+ gst_buffer_unmap (demux->common.cached_buffer, &demux->common.cached_map);
demux->common.cached_data = NULL;
}
gst_buffer_unref (demux->common.cached_buffer);
static GstBuffer *
gst_matroska_decode_buffer (GstMatroskaTrackContext * context, GstBuffer * buf)
{
- gpointer data, buf_data;
- gsize size, buf_size;
+ GstMapInfo map;
+ gpointer data;
+ gsize size;
g_return_val_if_fail (GST_IS_BUFFER (buf), NULL);
GST_DEBUG ("decoding buffer %p", buf);
- buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ);
-
- g_return_val_if_fail (buf_size > 0, buf);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
- data = buf_data;
- size = buf_size;
+ g_return_val_if_fail (size > 0, buf);
if (gst_matroska_decode_data (context->encodings, &data, &size,
GST_MATROSKA_TRACK_ENCODING_SCOPE_FRAME, FALSE)) {
- gst_buffer_unmap (buf, buf_data, buf_size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return gst_buffer_new_wrapped (data, size);
} else {
GST_DEBUG ("decode data failed");
- gst_buffer_unmap (buf, buf_data, buf_size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return NULL;
}
GstFlowReturn ret = GST_FLOW_OK;
const guint chunk = 64 * 1024;
GstBuffer *buf = NULL;
+ GstMapInfo map;
gpointer data = NULL;
gsize size;
guint64 length;
gint cluster_pos;
if (buf != NULL) {
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
}
GST_DEBUG_OBJECT (demux,
"read buffer size %" G_GSIZE_FORMAT " at offset %" G_GINT64_FORMAT,
gst_buffer_get_size (buf), newpos);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
gst_byte_reader_init (&reader, data, size);
resume:
cluster_pos = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
}
if (buf) {
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
}
GstMatroskaTrackAudioContext *audiocontext =
(GstMatroskaTrackAudioContext *) stream;
GstBuffer *newbuf = NULL;
+ GstMapInfo map, outmap;
guint8 *buf_data, *data;
Wavpack4Header wvh;
/* block_samples, flags and crc are already in the buffer */
newbuf = gst_buffer_new_allocate (NULL, sizeof (Wavpack4Header) - 12, 0);
- data = gst_buffer_map (newbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
+ data = outmap.data;
data[0] = 'w';
data[1] = 'v';
data[2] = 'p';
gsize buf_size, size, out_size = 0;
guint32 block_samples, flags, crc, blocksize;
- buf_data = gst_buffer_map (*buf, &buf_size, NULL, GST_MAP_READ);
+ gst_buffer_map (*buf, &map, GST_MAP_READ);
+ buf_data = map.data;
+ buf_size = map.size;
if (buf_size < 4) {
GST_ERROR_OBJECT (element, "Too small wavpack buffer");
- gst_buffer_unmap (*buf, buf_data, buf_size);
+ gst_buffer_unmap (*buf, &map);
return GST_FLOW_ERROR;
}
GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS, 0, -1);
outpos = 0;
- outdata = gst_buffer_map (newbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
+ outdata = outmap.data;
} else {
- gst_buffer_unmap (newbuf, outdata, out_size);
+ gst_buffer_unmap (newbuf, &outmap);
out_size += sizeof (Wavpack4Header) + blocksize;
gst_buffer_set_size (newbuf, out_size);
- outdata = gst_buffer_map (newbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
+ outdata = outmap.data;
}
outdata[outpos] = 'w';
data += blocksize;
size -= blocksize;
}
- gst_buffer_unmap (*buf, buf_data, buf_size);
+ gst_buffer_unmap (*buf, &map);
gst_buffer_unref (*buf);
if (newbuf)
- gst_buffer_unmap (newbuf, outdata, out_size);
+ gst_buffer_unmap (newbuf, &outmap);
*buf = newbuf;
audiocontext->wvpk_block_index += block_samples;
GError *err = NULL;
GstBuffer *newbuf;
gchar *utf8;
- gpointer data;
- gsize size;
+ GstMapInfo map;
sub_stream = (GstMatroskaTrackSubtitleContext *) stream;
- data = gst_buffer_map (*buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (*buf, &map, GST_MAP_READ);
if (!data) {
gst_buffer_unmap (*buf, data, -1);
}
if (!sub_stream->invalid_utf8) {
- if (g_utf8_validate (data, size, NULL)) {
+ if (g_utf8_validate ((gchar *) map.data, map.size, NULL)) {
goto next;
}
GST_WARNING_OBJECT (element, "subtitle stream %d is not valid UTF-8, this "
}
}
- utf8 = g_convert_with_fallback (data, size, "UTF-8", encoding, (char *) "*",
- NULL, NULL, &err);
+ utf8 =
+ g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8", encoding,
+ (char *) "*", NULL, NULL, &err);
if (err) {
GST_LOG_OBJECT (element, "could not convert string from '%s' to UTF-8: %s",
/* invalid input encoding, fall back to ISO-8859-15 (always succeeds) */
encoding = "ISO-8859-15";
- utf8 = g_convert_with_fallback (data, size, "UTF-8", encoding, (char *) "*",
- NULL, NULL, NULL);
+ utf8 =
+ g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8",
+ encoding, (char *) "*", NULL, NULL, NULL);
}
GST_LOG_OBJECT (element, "converted subtitle text from %s to UTF-8 %s",
gst_buffer_copy_into (newbuf, *buf,
GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_META,
0, -1);
- gst_buffer_unmap (*buf, data, size);
-
+ gst_buffer_unmap (*buf, &map);
gst_buffer_unref (*buf);
*buf = newbuf;
- data = gst_buffer_map (*buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (*buf, &map, GST_MAP_READ);
next:
if (sub_stream->check_markup) {
/* caps claim markup text, so we need to escape text,
* except if text is already markup and then needs no further escaping */
sub_stream->seen_markup_tag = sub_stream->seen_markup_tag ||
- gst_matroska_demux_subtitle_chunk_has_tag (element, data);
+ gst_matroska_demux_subtitle_chunk_has_tag (element, (gchar *) map.data);
if (!sub_stream->seen_markup_tag) {
- utf8 = g_markup_escape_text (data, size);
+ utf8 = g_markup_escape_text ((gchar *) map.data, map.size);
newbuf = gst_buffer_new_wrapped (utf8, strlen (utf8));
gst_buffer_copy_into (newbuf, *buf,
GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS |
GST_BUFFER_COPY_META, 0, -1);
- gst_buffer_unmap (*buf, data, size);
+ gst_buffer_unmap (*buf, &map);
gst_buffer_unref (*buf);
*buf = newbuf;
gst_matroska_demux_align_buffer (GstMatroskaDemux * demux,
GstBuffer * buffer, gsize alignment)
{
- gpointer data;
- gsize size;
+ GstMapInfo map;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- if (size < sizeof (guintptr)) {
- gst_buffer_unmap (buffer, data, size);
+ if (map.size < sizeof (guintptr)) {
+ gst_buffer_unmap (buffer, &map);
return buffer;
}
- if (((guintptr) data) & (alignment - 1)) {
+ if (((guintptr) map.data) & (alignment - 1)) {
GstBuffer *new_buffer;
- gpointer new_data;
new_buffer = gst_buffer_new_allocate (NULL,
gst_buffer_get_size (buffer), alignment);
+
/* Copy data "by hand", so ensure alignment is kept: */
- new_data = gst_buffer_map (new_buffer, NULL, NULL, GST_MAP_WRITE);
- memcpy (new_data, data, size);
- gst_buffer_unmap (new_buffer, new_data, -1);
+ gst_buffer_fill (new_buffer, 0, map.data, map.size);
+
gst_buffer_copy_into (new_buffer, buffer, GST_BUFFER_COPY_METADATA, 0, -1);
GST_DEBUG_OBJECT (demux,
"We want output aligned on %" G_GSIZE_FORMAT ", reallocated",
alignment);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return new_buffer;
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return buffer;
}
guint32 id;
guint64 block_duration = -1;
GstBuffer *buf = NULL;
- gpointer buf_data = NULL;
- gsize buf_size;
+ GstMapInfo map;
gint stream_num = -1, n, laces = 0;
guint size = 0;
gint *lace_size = NULL;
guint8 *data;
if (buf) {
- gst_buffer_unmap (buf, buf_data, buf_size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
}
if ((ret = gst_ebml_read_buffer (ebml, &id, &buf)) != GST_FLOW_OK)
break;
- buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ);
- data = buf_data;
- size = buf_size;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
/* first byte(s): blocknum */
if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
done:
if (buf) {
- gst_buffer_unmap (buf, buf_data, buf_size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
}
g_free (lace_size);
/* make up decoder-specific data if it is not supplied */
if (priv == NULL) {
+ GstMapInfo map;
+
priv = gst_buffer_new_allocate (NULL, 5, 0);
- data = gst_buffer_map (priv, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (priv, &map, GST_MAP_WRITE);
+ data = map.data;
rate_idx = aac_rate_idx (audiocontext->samplerate);
profile = aac_profile_idx (codec_id);
if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2,
strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2))) {
mpegversion = 2;
- gst_buffer_unmap (priv, data, 5);
+ gst_buffer_unmap (priv, &map);
gst_buffer_set_size (priv, 2);
} else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4,
strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4))) {
data[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
data[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
data[4] = (1 << 7) | (rate_idx << 3);
- gst_buffer_unmap (priv, data, 5);
+ gst_buffer_unmap (priv, &map);
} else {
- gst_buffer_unmap (priv, data, 5);
+ gst_buffer_unmap (priv, &map);
gst_buffer_set_size (priv, 2);
}
} else {
- gst_buffer_unmap (priv, data, 5);
+ gst_buffer_unmap (priv, &map);
gst_buffer_unref (priv);
priv = NULL;
GST_ERROR ("Unknown AAC profile and no codec private data");
} else {
if (gst_buffer_memcmp (buf0, 1, "vorbis", 6) == 0) {
GstMatroskaTrackAudioContext *audiocontext;
- guint8 *data, *hdr;
+ GstMapInfo map;
+ guint8 *hdr;
- data = gst_buffer_map (buf0, NULL, NULL, GST_MAP_READ);
- hdr = data + 1 + 6 + 4;
+ gst_buffer_map (buf0, &map, GST_MAP_READ);
+ hdr = map.data + 1 + 6 + 4;
audiocontext = (GstMatroskaTrackAudioContext *) context;
audiocontext->channels = GST_READ_UINT8 (hdr);
audiocontext->samplerate = GST_READ_UINT32_LE (hdr + 1);
- gst_buffer_unmap (buf0, data, -1);
+ gst_buffer_unmap (buf0, &map);
}
}
} else {
GstMatroskaTrackVideoContext *videocontext;
guint fps_num, fps_denom, par_num, par_denom;
- guint8 *data, *hdr;
+ GstMapInfo map;
+ guint8 *hdr;
- data = gst_buffer_map (buf0, NULL, NULL, GST_MAP_READ);
- hdr = data + 1 + 6 + 3 + 2 + 2;
+ gst_buffer_map (buf0, &map, GST_MAP_READ);
+ hdr = map.data + 1 + 6 + 3 + 2 + 2;
videocontext = (GstMatroskaTrackVideoContext *) context;
videocontext->pixel_width = GST_READ_UINT32_BE (hdr) >> 8;
}
hdr += 3 + 3;
- gst_buffer_unmap (buf0, data, -1);
+ gst_buffer_unmap (buf0, &map);
}
if (buf0)
if (value)
buf = gst_value_get_buffer (value);
if (buf != NULL) {
- guint8 *priv_data = NULL, *priv_buffer_data;
- gsize priv_data_size = 0;
+ GstMapInfo map;
+ guint8 *priv_data = NULL;
- priv_buffer_data =
- gst_buffer_map (buf, &priv_data_size, NULL, GST_MAP_READ);
- if (priv_data_size > SUBTITLE_MAX_CODEC_PRIVATE) {
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+
+ if (map.size > SUBTITLE_MAX_CODEC_PRIVATE) {
GST_WARNING_OBJECT (mux, "pad %" GST_PTR_FORMAT " subtitle private data"
" exceeded maximum (%d); discarding", pad,
SUBTITLE_MAX_CODEC_PRIVATE);
- gst_buffer_unmap (buf, priv_data, priv_data_size);
+ gst_buffer_unmap (buf, &map);
return TRUE;
}
gst_matroska_mux_free_codec_priv (context);
- priv_data = g_malloc0 (priv_data_size);
- memcpy (priv_data, priv_buffer_data, priv_data_size);
+ priv_data = g_malloc0 (map.size);
+ memcpy (priv_data, map.data, map.size);
context->codec_priv = priv_data;
- context->codec_priv_size = priv_data_size;
- gst_buffer_unmap (buf, priv_buffer_data, priv_data_size);
+ context->codec_priv_size = map.size;
+ gst_buffer_unmap (buf, &map);
}
GST_DEBUG_OBJECT (pad, "codec_id %s, codec data size %" G_GSIZE_FORMAT,
{
GstMatroskaTrackVideoContext *ctx =
(GstMatroskaTrackVideoContext *) collect_pad->track;
- guint8 *buf_data, *data;
+ GstMapInfo map;
+ guint8 *data;
gsize size;
guint8 parse_code;
guint32 next_parse_offset;
GstBuffer *ret = NULL;
gboolean is_muxing_unit = FALSE;
- buf_data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- data = buf_data;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
if (size < 13) {
- gst_buffer_unmap (buf, buf_data, -1);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return ret;
}
/* Check if this buffer contains a picture or end-of-sequence packet */
while (size >= 13) {
if (GST_READ_UINT32_BE (data) != 0x42424344 /* 'BBCD' */ ) {
- gst_buffer_unmap (buf, buf_data, -1);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return ret;
}
else
ctx->dirac_unit = gst_buffer_ref (buf);
- gst_buffer_unmap (buf, buf_data, -1);
+ gst_buffer_unmap (buf, &map);
if (is_muxing_unit) {
ret = gst_buffer_make_writable (ctx->dirac_unit);
GstFlowReturn ret = GST_FLOW_OK;
const guint chunk = 64 * 1024;
GstBuffer *buf = NULL;
+ GstMapInfo map;
gpointer data;
gsize size;
guint64 length;
GST_DEBUG_OBJECT (parse,
"read buffer size %" G_GSIZE_FORMAT " at offset %" G_GINT64_FORMAT,
gst_buffer_get_size (buf), newpos);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
gst_byte_reader_init (&reader, data, size);
cluster_pos = 0;
resume:
} else {
/* partial cluster id may have been in tail of buffer */
newpos += MAX (size, 4) - 3;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
}
}
if (buf) {
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
buf = NULL;
}
guint32 id;
guint64 block_duration = 0;
GstBuffer *buf = NULL;
- gpointer buf_data = NULL;
- gsize buf_size = 0;
+ GstMapInfo map;
gint stream_num = -1, n, laces = 0;
guint size = 0;
gint *lace_size = NULL;
if ((ret = gst_ebml_read_buffer (ebml, &id, &buf)) != GST_FLOW_OK)
break;
- buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ);
-
- data = buf_data;
- size = buf_size;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
/* first byte(s): blocknum */
if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
done:
if (buf) {
- gst_buffer_unmap (buf, buf_data, buf_size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
}
g_free (lace_size);
*p_buf = gst_buffer_copy_region (common->cached_buffer,
GST_BUFFER_COPY_ALL, common->offset - cache_offset, size);
if (bytes) {
- if (!common->cached_data)
- common->cached_data = gst_buffer_map (common->cached_buffer,
- NULL, NULL, GST_MAP_READ);
+ if (!common->cached_data) {
+ gst_buffer_map (common->cached_buffer, &common->cached_map,
+ GST_MAP_READ);
+ common->cached_data = common->cached_map.data;
+ }
*bytes = common->cached_data + common->offset - cache_offset;
}
return GST_FLOW_OK;
}
/* not enough data in the cache, free cache and get a new one */
if (common->cached_data) {
- gst_buffer_unmap (common->cached_buffer, common->cached_data, -1);
+ gst_buffer_unmap (common->cached_buffer, &common->cached_map);
common->cached_data = NULL;
}
gst_buffer_unref (common->cached_buffer);
*p_buf = gst_buffer_copy_region (common->cached_buffer,
GST_BUFFER_COPY_ALL, 0, size);
if (bytes) {
- common->cached_data = gst_buffer_map (common->cached_buffer,
- NULL, NULL, GST_MAP_READ);
+ gst_buffer_map (common->cached_buffer, &common->cached_map, GST_MAP_READ);
+ common->cached_data = common->cached_map.data;
*bytes = common->cached_data;
}
return GST_FLOW_OK;
*p_buf = gst_buffer_copy_region (common->cached_buffer,
GST_BUFFER_COPY_ALL, 0, size);
if (bytes) {
- common->cached_data = gst_buffer_map (common->cached_buffer,
- NULL, NULL, GST_MAP_READ);
+ gst_buffer_map (common->cached_buffer, &common->cached_map, GST_MAP_READ);
+ common->cached_data = common->cached_map.data;
*bytes = common->cached_data;
}
/* pull mode caching */
GstBuffer *cached_buffer;
guint8 *cached_data;
+ GstMapInfo cached_map;
/* push and pull mode */
guint64 offset;
for (i = 0; i < sink->n_streamheaders; i++) {
GstBuffer *hdr;
- guint8 *sdata;
- gsize ssize;
+ GstMapInfo map;
int ret;
hdr = sink->streamheaders[i];
- sdata = gst_buffer_map (hdr, &ssize, NULL, GST_MAP_READ);
- ret = fwrite (sdata, ssize, 1, sink->file);
- gst_buffer_unmap (hdr, sdata, ssize);
+ gst_buffer_map (hdr, &map, GST_MAP_READ);
+ ret = fwrite (map.data, map.size, 1, sink->file);
+ gst_buffer_unmap (hdr, &map);
if (ret != 1)
return FALSE;
- sink->cur_file_size += ssize;
+ sink->cur_file_size += map.size;
}
return TRUE;
gst_multi_file_sink_render (GstBaseSink * sink, GstBuffer * buffer)
{
GstMultiFileSink *multifilesink;
- gsize size;
- guint8 *data;
+ GstMapInfo map;
gchar *filename;
gboolean ret;
GError *error = NULL;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
multifilesink = GST_MULTI_FILE_SINK (sink);
filename = g_strdup_printf (multifilesink->filename,
multifilesink->index);
- ret = g_file_set_contents (filename, (char *) data, size, &error);
+ ret = g_file_set_contents (filename, (char *) map.data, map.size, &error);
if (!ret)
goto write_error;
goto stdio_write_error;
}
- ret = fwrite (data, size, 1, multifilesink->file);
+ ret = fwrite (map.data, map.size, 1, multifilesink->file);
if (ret != 1)
goto stdio_write_error;
gst_multi_file_sink_write_stream_headers (multifilesink);
}
- ret = fwrite (data, size, 1, multifilesink->file);
+ ret = fwrite (map.data, map.size, 1, multifilesink->file);
if (ret != 1)
goto stdio_write_error;
if (!gst_multi_file_sink_write_stream_headers (multifilesink))
goto stdio_write_error;
- ret = fwrite (data, size, 1, multifilesink->file);
+ ret = fwrite (map.data, map.size, 1, multifilesink->file);
if (ret != 1)
goto stdio_write_error;
case GST_MULTI_FILE_SINK_NEXT_MAX_SIZE:{
guint64 new_size;
- new_size = multifilesink->cur_file_size + size;
+ new_size = multifilesink->cur_file_size + map.size;
if (new_size > multifilesink->max_file_size) {
GST_INFO_OBJECT (multifilesink, "current size: %" G_GUINT64_FORMAT
gst_multi_file_sink_write_stream_headers (multifilesink);
}
- ret = fwrite (data, size, 1, multifilesink->file);
+ ret = fwrite (map.data, map.size, 1, multifilesink->file);
if (ret != 1)
goto stdio_write_error;
- multifilesink->cur_file_size += size;
+ multifilesink->cur_file_size += map.size;
break;
}
default:
g_assert_not_reached ();
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_OK;
/* ERRORS */
g_error_free (error);
g_free (filename);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_ERROR;
}
stdio_write_error:
GST_ELEMENT_ERROR (multifilesink, RESOURCE, WRITE,
("Error while writing to file."), ("%s", g_strerror (errno)));
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_ERROR;
}
GstBuffer *buf;
GError *err = NULL;
guint64 read_offset;
+ GstMapInfo map;
guint8 *data;
guint to_read;
GST_BUFFER_OFFSET (buf) = offset;
- data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ data = map.data;
cancel = src->cancellable;
GST_BUFFER_OFFSET_END (buf) = offset;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
*buffer = buf;
GST_LOG_OBJECT (src, "read %" G_GSIZE_FORMAT " bytes into buf %p",
gst_rg_analysis_transform_ip (GstBaseTransform * base, GstBuffer * buf)
{
GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
- guint8 *data;
- gsize size;
+ GstMapInfo map;
g_return_val_if_fail (filter->ctx != NULL, GST_FLOW_WRONG_STATE);
g_return_val_if_fail (filter->analyze != NULL, GST_FLOW_NOT_NEGOTIATED);
if (filter->skip)
return GST_FLOW_OK;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- GST_LOG_OBJECT (filter, "processing buffer of size %" G_GSIZE_FORMAT, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ GST_LOG_OBJECT (filter, "processing buffer of size %" G_GSIZE_FORMAT,
+ map.size);
rg_analysis_start_buffer (filter->ctx, GST_BUFFER_TIMESTAMP (buf));
- filter->analyze (filter->ctx, data, size, filter->depth);
+ filter->analyze (filter->ctx, map.data, map.size, filter->depth);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
{
GstRgLimiter *filter = GST_RG_LIMITER (base);
gfloat *input;
- guint8 *data;
+ GstMapInfo map;
guint count;
guint i;
if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP))
return GST_FLOW_OK;
- data = gst_buffer_map (buf, NULL, NULL, GST_MAP_READ);
- input = (gfloat *) data;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ input = (gfloat *) map.data;
count = gst_buffer_get_size (buf) / sizeof (gfloat);
for (i = count; i--;) {
input++;
}
- gst_buffer_unmap (buf, data, -1);
+ gst_buffer_unmap (buf, &map);
return GST_FLOW_OK;
}
guint32 samples;
guint16 asterisk_len;
GstRTPBuffer rtp = { NULL };
- guint8 *data;
+ GstMapInfo map;
gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp);
samples = timestamp - asteriskh263->lastts;
asteriskh263->lastts = timestamp;
- data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- GST_ASTERISKH263_HEADER_TIMESTAMP (data) = g_htonl (samples);
- GST_ASTERISKH263_HEADER_LENGTH (data) = g_htons (asterisk_len);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ GST_ASTERISKH263_HEADER_TIMESTAMP (map.data) = g_htonl (samples);
+ GST_ASTERISKH263_HEADER_LENGTH (map.data) = g_htons (asterisk_len);
/* copy the data into place */
- memcpy (data + GST_ASTERISKH263_HEADER_LEN, payload, payload_len);
+ memcpy (map.data + GST_ASTERISKH263_HEADER_LEN, payload, payload_len);
- gst_buffer_unmap (outbuf, data, -1);
+ gst_buffer_unmap (outbuf, &map);
GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
if (!gst_pad_has_current_caps (asteriskh263->srcpad)) {
{
GstRtpAC3Pay *rtpac3pay;
GstFlowReturn ret;
- gsize size, avail, left, NF;
- guint8 *data, *p;
+ gsize avail, left, NF;
+ GstMapInfo map;
+ guint8 *p;
guint packet_len;
GstClockTime duration, timestamp;
rtpac3pay = GST_RTP_AC3_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
duration = GST_BUFFER_DURATION (buffer);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
/* count the amount of incomming packets */
NF = 0;
- left = size;
- p = data;
+ left = map.size;
+ p = map.data;
while (TRUE) {
guint bsid, fscod, frmsizecod, frame_size;
p += frame_size;
left -= frame_size;
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
if (NF == 0)
goto no_frames;
/* get packet length of previous data and this new data,
* payload length includes a 4 byte header */
- packet_len = gst_rtp_buffer_calc_packet_len (2 + avail + size, 0, 0);
+ packet_len = gst_rtp_buffer_calc_packet_len (2 + avail + map.size, 0, 0);
/* if this buffer is going to overflow the packet, flush what we
* have. */
GstBuffer *outbuf = NULL;
gint payload_len;
GstRTPBuffer rtp = { NULL };
- guint8 *odata;
- gsize osize;
+ GstMapInfo map;
rtpamrdepay = GST_RTP_AMR_DEPAY (depayload);
outbuf = gst_buffer_new_and_alloc (payload_len);
/* point to destination */
- odata = gst_buffer_map (outbuf, &osize, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
/* point to first data packet */
- p = odata;
+ p = map.data;
dp = payload + num_packets;
if (rtpamrdepay->crc) {
/* skip CRC if present */
dp += fr_size;
}
}
- gst_buffer_unmap (outbuf, odata, osize);
+ gst_buffer_unmap (outbuf, &map);
/* we can set the duration because each packet is 20 milliseconds */
GST_BUFFER_DURATION (outbuf) = num_packets * 20 * GST_MSECOND;
const gint *frame_size;
GstFlowReturn ret;
guint payload_len;
- gsize size;
+ GstMapInfo map;
GstBuffer *outbuf;
- guint8 *payload, *data, *ptr, *payload_amr;
+ guint8 *payload, *ptr, *payload_amr;
GstClockTime timestamp, duration;
guint packet_len, mtu;
gint i, num_packets, num_nonempty_packets;
rtpamrpay = GST_RTP_AMR_PAY (basepayload);
mtu = GST_RTP_BASE_PAYLOAD_MTU (rtpamrpay);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
duration = GST_BUFFER_DURATION (buffer);
else
frame_size = wb_frame_size;
- GST_DEBUG_OBJECT (basepayload, "got %" G_GSIZE_FORMAT " bytes", size);
+ GST_DEBUG_OBJECT (basepayload, "got %" G_GSIZE_FORMAT " bytes", map.size);
/* FIXME, only
* octet aligned, no interleaving, single channel, no CRC,
/* first count number of packets and total amr frame size */
amr_len = num_packets = num_nonempty_packets = 0;
- for (i = 0; i < size; i++) {
+ for (i = 0; i < map.size; i++) {
guint8 FT;
gint fr_size;
- FT = (data[i] & 0x78) >> 3;
+ FT = (map.data[i] & 0x78) >> 3;
fr_size = frame_size[FT];
GST_DEBUG_OBJECT (basepayload, "frame type %d, frame size %d", FT, fr_size);
num_packets++;
i += fr_size;
}
- if (amr_len > size)
+ if (amr_len > map.size)
goto incomplete_frame;
/* we need one extra byte for the CMR, the ToC is in the input
* data */
- payload_len = size + 1;
+ payload_len = map.size + 1;
/* get packet len to check against MTU */
packet_len = gst_rtp_buffer_calc_packet_len (payload_len, 0, 0);
/* copy data in payload, first we copy all the FTs then all
* the AMR data. The last FT has to have the F flag cleared. */
- ptr = data;
+ ptr = map.data;
for (i = 1; i <= num_packets; i++) {
guint8 FT;
gint fr_size;
payload_amr += fr_size;
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
gst_rtp_buffer_unmap (&rtp);
{
GST_ELEMENT_ERROR (basepayload, STREAM, FORMAT,
(NULL), ("received AMR frame with size <= 0"));
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
{
GST_ELEMENT_ERROR (basepayload, STREAM, FORMAT,
(NULL), ("received incomplete AMR frames"));
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
{
GST_ELEMENT_ERROR (basepayload, STREAM, FORMAT,
(NULL), ("received too many AMR frames for MTU"));
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
GstRtpCELTDepay *rtpceltdepay;
gint clock_rate, nb_channels = 0, frame_size = 0;
GstBuffer *buf;
- guint8 *data, *ptr;
- gsize size;
+ GstMapInfo map;
+ guint8 *ptr;
const gchar *params;
GstCaps *srccaps;
gboolean res;
/* construct minimal header and comment packet for the decoder */
buf = gst_buffer_new_and_alloc (60);
- ptr = data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ ptr = map.data;
memcpy (ptr, "CELT ", 8);
ptr += 8;
memcpy (ptr, "1.1.12", 7);
GST_WRITE_UINT32_LE (ptr, -1); /* bytes_per_packet */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, 0); /* extra headers */
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
srccaps = gst_caps_new_empty_simple ("audio/x-celt");
res = gst_pad_set_caps (depayload->srcpad, srccaps);
{
GstFlowReturn ret;
GstRtpCELTPay *rtpceltpay;
- gsize size, payload_len;
- guint8 *data;
+ gsize payload_len;
+ GstMapInfo map;
GstClockTime duration, packet_dur;
guint i, ssize, packet_len;
ret = GST_FLOW_OK;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
switch (rtpceltpay->packet) {
case 0:
/* ident packet. We need to parse the headers to construct the RTP
* properties. */
- if (!gst_rtp_celt_pay_parse_ident (rtpceltpay, data, size))
+ if (!gst_rtp_celt_pay_parse_ident (rtpceltpay, map.data, map.size))
goto parse_error;
goto cleanup;
/* other packets go in the payload */
break;
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
duration = GST_BUFFER_DURATION (buffer);
GST_LOG_OBJECT (rtpceltpay,
"got buffer of duration %" GST_TIME_FORMAT ", size %" G_GSIZE_FORMAT,
- GST_TIME_ARGS (duration), size);
+ GST_TIME_ARGS (duration), map.size);
/* calculate the size of the size field and the payload */
ssize = 1;
- for (i = size; i > 0xff; i -= 0xff)
+ for (i = map.size; i > 0xff; i -= 0xff)
ssize++;
GST_DEBUG_OBJECT (rtpceltpay, "bytes for size %u", ssize);
/* calculate what the new size and duration would be of the packet */
- payload_len = ssize + size + rtpceltpay->bytes + rtpceltpay->sbytes;
+ payload_len = ssize + map.size + rtpceltpay->bytes + rtpceltpay->sbytes;
if (rtpceltpay->qduration != -1 && duration != -1)
packet_dur = rtpceltpay->qduration + duration;
else
}
/* queue the packet */
- gst_rtp_celt_pay_add_queued (rtpceltpay, buffer, ssize, size, duration);
+ gst_rtp_celt_pay_add_queued (rtpceltpay, buffer, ssize, map.size, duration);
done:
rtpceltpay->packet++;
/* ERRORS */
cleanup:
{
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
goto done;
}
parse_error:
{
GST_ELEMENT_ERROR (rtpceltpay, STREAM, DECODE, (NULL),
("Error parsing first identification packet."));
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_ERROR;
}
}
gint clock_rate;
gboolean systemstream, ret;
const gchar *encode, *media;
- guint8 *data;
- gsize size;
rtpdvdepay = GST_RTP_DV_DEPAY (depayload);
/* Initialize the new accumulator frame.
* If the previous frame exists, copy that into the accumulator frame.
* This way, missing packets in the stream won't show up badly. */
- data = gst_buffer_map (rtpdvdepay->acc, &size, NULL, GST_MAP_WRITE);
- memset (data, 0, rtpdvdepay->frame_size);
- gst_buffer_unmap (rtpdvdepay->acc, data, size);
+ gst_buffer_memset (rtpdvdepay->acc, 0, 0, rtpdvdepay->frame_size);
srccaps = gst_caps_new_simple ("video/x-dv",
"systemstream", G_TYPE_BOOLEAN, systemstream,
GstBuffer *outbuf;
GstFlowReturn ret = GST_FLOW_OK;
gint hdrlen;
- gsize size, osize;
- guint8 *data, *odata;
+ gsize size;
+ GstMapInfo map;
+ guint8 *data;
guint8 *dest;
guint filled;
GstRTPBuffer rtp = { NULL, };
max_payload_size = ((GST_RTP_BASE_PAYLOAD_MTU (rtpdvpay) - hdrlen) / 80) * 80;
/* The length of the buffer to transmit. */
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
-
- odata = data;
- osize = size;
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
GST_DEBUG_OBJECT (rtpdvpay,
"DV RTP payloader got buffer of %" G_GSIZE_FORMAT
outbuf = NULL;
}
}
- gst_buffer_unmap (buffer, odata, osize);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return ret;
gst_rtp_g723_pay_handle_buffer (GstRTPBasePayload * payload, GstBuffer * buf)
{
GstFlowReturn ret = GST_FLOW_OK;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint8 HDR;
GstRTPG723Pay *pay;
GstClockTime packet_dur, timestamp;
pay = GST_RTP_G723_PAY (payload);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
timestamp = GST_BUFFER_TIMESTAMP (buf);
if (GST_BUFFER_IS_DISCONT (buf)) {
}
/* should be one of these sizes */
- if (size != 4 && size != 20 && size != 24)
+ if (map.size != 4 && map.size != 20 && map.size != 24)
goto invalid_size;
/* check size by looking at the header bits */
- HDR = data[0] & 0x3;
- if (size_tab[HDR] != size)
+ HDR = map.data[0] & 0x3;
+ if (size_tab[HDR] != map.size)
goto wrong_size;
/* calculate packet size and duration */
- payload_len = gst_adapter_available (pay->adapter) + size;
+ payload_len = gst_adapter_available (pay->adapter) + map.size;
packet_dur = pay->duration + G723_FRAME_DURATION;
packet_len = gst_rtp_buffer_calc_packet_len (payload_len, 0, 0);
else
pay->timestamp = 0;
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
/* add packet to the queue */
gst_adapter_push (pay->adapter, buf);
{
GST_ELEMENT_WARNING (pay, STREAM, WRONG_TYPE,
("Invalid input buffer size"),
- ("Input size should be 4, 20 or 24, got %" G_GSIZE_FORMAT, size));
- gst_buffer_unmap (buf, data, size);
+ ("Input size should be 4, 20 or 24, got %" G_GSIZE_FORMAT, map.size));
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return GST_FLOW_OK;
}
GST_ELEMENT_WARNING (pay, STREAM, WRONG_TYPE,
("Wrong input buffer size"),
("Expected input buffer size %u but got %" G_GSIZE_FORMAT,
- size_tab[HDR], size));
- gst_buffer_unmap (buf, data, size);
+ size_tab[HDR], map.size));
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return GST_FLOW_OK;
}
if (!outbuf)
goto bad_len;
} else {
- guint8 *in, *out, tmp, *odata;
+ guint8 *in, *out, tmp;
guint len;
- gsize osize;
+ GstMapInfo map;
in = gst_rtp_buffer_get_payload (&rtp);
len = gst_rtp_buffer_get_payload_len (&rtp);
goto bad_len;
outbuf = gst_buffer_make_writable (outbuf);
- odata = gst_buffer_map (outbuf, &osize, NULL, GST_MAP_WRITE);
- out = odata;
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ out = map.data;
/* we need to reshuffle the bytes, input is always of the form
* A B C D ... with the number of bits depending on the bitrate. */
break;
}
}
- gst_buffer_unmap (outbuf, odata, osize);
+ gst_buffer_unmap (outbuf, &map);
}
if (marker) {
pay = GST_RTP_G726_PAY (payload);
if (!pay->aal2) {
+ GstMapInfo map;
guint8 *data, tmp;
- gsize len;
+ gsize size;
/* for non AAL2, we need to reshuffle the bytes, we can do this in-place
* when the buffer is writable. */
buffer = gst_buffer_make_writable (buffer);
- data = gst_buffer_map (buffer, &len, NULL, GST_MAP_READWRITE);
+ gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
+ data = map.data;
+ size = map.size;
- GST_LOG_OBJECT (pay, "packing %" G_GSIZE_FORMAT " bytes of data", len);
+ GST_LOG_OBJECT (pay, "packing %" G_GSIZE_FORMAT " bytes of data", map.size);
/* we need to reshuffle the bytes, output is of the form:
* A B C D .. with the number of bits depending on the bitrate. */
* |0 1|0 1|0 1|0 1|
* +-+-+-+-+-+-+-+-+-
*/
- while (len > 0) {
+ while (size > 0) {
tmp = *data;
*data++ = ((tmp & 0xc0) >> 6) |
((tmp & 0x30) >> 2) | ((tmp & 0x0c) << 2) | ((tmp & 0x03) << 6);
- len--;
+ size--;
}
break;
}
* |1 2|0 1 2|0 1 2|2|0 1 2|0 1 2|0|0 1 2|0 1 2|0 1|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
*/
- while (len > 2) {
+ while (size > 2) {
tmp = *data;
*data++ = ((tmp & 0xc0) >> 6) |
((tmp & 0x38) >> 1) | ((tmp & 0x07) << 5);
tmp = *data;
*data++ = ((tmp & 0xe0) >> 5) |
((tmp & 0x1c) >> 2) | ((tmp & 0x03) << 6);
- len -= 3;
+ size -= 3;
}
break;
}
* |0 1 2 3|0 1 2 3|0 1 2 3|0 1 2 3|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
*/
- while (len > 0) {
+ while (size > 0) {
tmp = *data;
*data++ = ((tmp & 0xf0) >> 4) | ((tmp & 0x0f) << 4);
- len--;
+ size--;
}
break;
}
* |2 3 4|0 1 2 3 4|4|0 1 2 3 4|0 1|1 2 3 4|0 1 2 3|3 4|0 1 2 3 4|0|0 1 2 3 4|0 1 2|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
*/
- while (len > 4) {
+ while (size > 4) {
tmp = *data;
*data++ = ((tmp & 0xe0) >> 5) | ((tmp & 0x1f) << 3);
tmp = *data;
((tmp & 0x3e) << 2) | ((tmp & 0x01) << 7);
tmp = *data;
*data++ = ((tmp & 0xf8) >> 3) | ((tmp & 0x07) << 5);
- len -= 5;
+ size -= 5;
}
break;
}
}
- gst_buffer_unmap (buffer, data, len);
+ gst_buffer_unmap (buffer, &map);
}
res =
rtpg729pay->next_ts = timestamp;
if (available == 0 && size >= min_payload_len && size <= max_payload_len) {
- guint8 *data;
+ GstMapInfo map;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- ret = gst_rtp_g729_pay_push (rtpg729pay, data, size);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ ret = gst_rtp_g729_pay_push (rtpg729pay, map.data, map.size);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
return ret;
}
GstRTPGSMPay *rtpgsmpay;
guint payload_len;
GstBuffer *outbuf;
- guint8 *payload, *data;
+ GstMapInfo map;
+ guint8 *payload;
GstClockTime timestamp, duration;
GstFlowReturn ret;
- gsize size;
GstRTPBuffer rtp = { NULL };
rtpgsmpay = GST_RTP_GSM_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
duration = GST_BUFFER_DURATION (buffer);
/* FIXME, only one GSM frame per RTP packet for now */
- payload_len = size;
+ payload_len = map.size;
/* FIXME, just error out for now */
if (payload_len > GST_RTP_BASE_PAYLOAD_MTU (rtpgsmpay))
/* copy data in payload */
payload = gst_rtp_buffer_get_payload (&rtp);
- memcpy (payload, data, size);
+ memcpy (payload, map.data, map.size);
gst_rtp_buffer_unmap (&rtp);
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
GST_DEBUG ("gst_rtp_gsm_pay_chain: pushing buffer of size %" G_GSIZE_FORMAT,
GST_ELEMENT_ERROR (rtpgsmpay, STREAM, ENCODE, (NULL),
("payload_len %u > mtu %u", payload_len,
GST_RTP_BASE_PAYLOAD_MTU (rtpgsmpay)));
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
return GST_FLOW_ERROR;
}
}
if (payload[0] & 0x80) {
guint b, csize, left, offset;
- gsize size;
- guint8 *data;
+ GstMapInfo map;
GstBuffer *subbuf;
/* C bit, we have inline caps */
- data = gst_buffer_map (outbuf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (outbuf, &map, GST_MAP_READ);
/* start reading the length, we need this to skip to the data later */
csize = offset = 0;
- left = size;
+ left = map.size;
do {
if (offset >= left) {
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_unmap (outbuf, &map);
goto too_small;
}
- b = data[offset++];
+ b = map.data[offset++];
csize = (csize << 7) | (b & 0x7f);
} while (b & 0x80);
if (left < csize) {
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_unmap (outbuf, &map);
goto too_small;
}
/* parse and store in cache */
- outcaps = gst_caps_from_string ((gchar *) & data[offset]);
+ outcaps = gst_caps_from_string ((gchar *) & map.data[offset]);
store_cache (rtpgstdepay, CV, outcaps);
/* skip caps */
"inline caps %u, length %u, %" GST_PTR_FORMAT, CV, csize, outcaps);
/* create real data buffer when needed */
- if (size)
+ if (map.size)
subbuf =
gst_buffer_copy_region (outbuf, GST_BUFFER_COPY_ALL, offset, left);
else
subbuf = NULL;
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_unmap (outbuf, &map);
gst_buffer_unref (outbuf);
outbuf = subbuf;
}
GstBuffer * buffer)
{
GstRtpGSTPay *rtpgstpay;
- guint8 *data, *ptr;
- gsize size, left;
+ GstMapInfo map;
+ guint8 *ptr;
+ gsize left;
GstBuffer *outbuf;
GstFlowReturn ret;
GstClockTime timestamp;
rtpgstpay = GST_RTP_GST_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
ret = GST_FLOW_OK;
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
frag_offset = 0;
- ptr = data;
- left = size;
+ ptr = map.data;
+ left = map.size;
while (left > 0) {
guint towrite;
ret = gst_rtp_base_payload_push (basepayload, outbuf);
}
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return ret;
/* frame is completed: append to previous, push it out */
guint len, padlen;
guint avail;
- guint8 *data;
+ GstMapInfo map;
GST_LOG_OBJECT (depayload, "Frame complete");
outbuf = gst_buffer_new_and_alloc (len + padlen);
- data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- memset (data + len, 0, padlen);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ memset (map.data + len, 0, padlen);
/* prepend previous data */
if (avail > 0) {
- gst_adapter_copy (rtph263pdepay->adapter, data, 0, avail);
+ gst_adapter_copy (rtph263pdepay->adapter, map.data, 0, avail);
gst_adapter_flush (rtph263pdepay->adapter, avail);
}
- memcpy (data + avail, payload, payload_len);
- gst_buffer_unmap (outbuf, data, len);
+ memcpy (map.data + avail, payload, payload_len);
+ gst_buffer_unmap (outbuf, &map);
gst_rtp_buffer_unmap (&rtp);
return outbuf;
GstRtpH264Depay *rtph264depay;
const gchar *ps, *profile;
GstBuffer *codec_data;
- guint8 *ptr, *data;
+ GstMapInfo map;
+ guint8 *ptr;
gboolean res;
rtph264depay = GST_RTP_H264_DEPAY (depayload);
/* we seriously overshoot the length, but it's fine. */
codec_data = gst_buffer_new_and_alloc (len);
- data = gst_buffer_map (codec_data, NULL, NULL, GST_MAP_WRITE);
- ptr = data;
+ gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
+ ptr = map.data;
total = 0;
for (i = 0; params[i]; i++) {
guint save = 0;
total += len + sizeof (sync_bytes);
ptr += len;
}
- gst_buffer_unmap (codec_data, data, total);
+ gst_buffer_unmap (codec_data, &map);
+ gst_buffer_resize (codec_data, 0, total);
g_strfreev (params);
/* keep the codec_data, we need to send it as the first buffer. We cannot
codec_data = gst_buffer_new_and_alloc (len);
- data = ptr = gst_buffer_map (codec_data, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
+ ptr = map.data;
/* 8 bits version == 1 */
*ptr++ = 1;
ptr += len;
}
g_free (pps);
- gst_buffer_unmap (codec_data, data, ptr - data);
+ gst_buffer_resize (codec_data, 0, ptr - map.data);
+ gst_buffer_unmap (codec_data, &map);
gst_caps_set_simple (srccaps,
"codec_data", GST_TYPE_BUFFER, codec_data, NULL);
{
GstRTPBaseDepayload *depayload = GST_RTP_BASE_DEPAYLOAD (rtph264depay);
gint nal_type;
- gsize size;
- guint8 *data;
+ GstMapInfo map;
GstBuffer *outbuf = NULL;
GstClockTime out_timestamp;
gboolean keyframe, out_keyframe;
- data = gst_buffer_map (nal, &size, NULL, GST_MAP_READ);
- if (G_UNLIKELY (size < 5))
+ gst_buffer_map (nal, &map, GST_MAP_READ);
+ if (G_UNLIKELY (map.size < 5))
goto short_nal;
- nal_type = data[4] & 0x1f;
+ nal_type = map.data[4] & 0x1f;
GST_DEBUG_OBJECT (rtph264depay, "handle NAL type %d", nal_type);
keyframe = NAL_TYPE_IS_KEY (nal_type);
if (nal_type == 1 || nal_type == 2 || nal_type == 5) {
/* we have a picture start */
start = TRUE;
- if (data[5] & 0x80) {
+ if (map.data[5] & 0x80) {
/* first_mb_in_slice == 0 completes a picture */
complete = TRUE;
}
GST_DEBUG_OBJECT (depayload, "using NAL as output");
outbuf = nal;
}
- gst_buffer_unmap (nal, data, size);
+ gst_buffer_unmap (nal, &map);
if (outbuf) {
/* prepend codec_data */
short_nal:
{
GST_WARNING_OBJECT (depayload, "dropping short NAL");
- gst_buffer_unmap (nal, data, size);
+ gst_buffer_unmap (nal, &map);
gst_buffer_unref (nal);
return NULL;
}
gboolean send)
{
guint outsize;
- guint8 *outdata;
+ GstMapInfo map;
GstBuffer *outbuf;
outsize = gst_adapter_available (rtph264depay->adapter);
outbuf = gst_adapter_take_buffer (rtph264depay->adapter, outsize);
- outdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
GST_DEBUG_OBJECT (rtph264depay, "output %d bytes", outsize);
if (rtph264depay->byte_stream) {
- memcpy (outdata, sync_bytes, sizeof (sync_bytes));
+ memcpy (map.data, sync_bytes, sizeof (sync_bytes));
} else {
outsize -= 4;
- outdata[0] = (outsize >> 24);
- outdata[1] = (outsize >> 16);
- outdata[2] = (outsize >> 8);
- outdata[3] = (outsize);
+ map.data[0] = (outsize >> 24);
+ map.data[1] = (outsize >> 16);
+ map.data[2] = (outsize >> 8);
+ map.data[3] = (outsize);
}
- gst_buffer_unmap (outbuf, outdata, -1);
+ gst_buffer_unmap (outbuf, &map);
rtph264depay->current_fu_type = 0;
guint8 *payload;
guint header_len;
guint8 nal_ref_idc;
- guint8 *outdata;
+ GstMapInfo map;
guint outsize, nalu_size;
GstClockTime timestamp;
gboolean marker;
outsize = nalu_size + sizeof (sync_bytes);
outbuf = gst_buffer_new_and_alloc (outsize);
- outdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
if (rtph264depay->byte_stream) {
- memcpy (outdata, sync_bytes, sizeof (sync_bytes));
+ memcpy (map.data, sync_bytes, sizeof (sync_bytes));
} else {
- outdata[0] = outdata[1] = 0;
- outdata[2] = payload[0];
- outdata[3] = payload[1];
+ map.data[0] = map.data[1] = 0;
+ map.data[2] = payload[0];
+ map.data[3] = payload[1];
}
/* strip NALU size */
payload += 2;
payload_len -= 2;
- memcpy (outdata + sizeof (sync_bytes), payload, nalu_size);
- gst_buffer_unmap (outbuf, outdata, outsize);
+ memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
+ gst_buffer_unmap (outbuf, &map);
gst_adapter_push (rtph264depay->adapter, outbuf);
outsize = nalu_size + sizeof (sync_bytes);
outbuf = gst_buffer_new_and_alloc (outsize);
- outdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- memcpy (outdata + sizeof (sync_bytes), payload, nalu_size);
- outdata[sizeof (sync_bytes)] = nal_header;
- gst_buffer_unmap (outbuf, outdata, outsize);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
+ map.data[sizeof (sync_bytes)] = nal_header;
+ gst_buffer_unmap (outbuf, &map);
GST_DEBUG_OBJECT (rtph264depay, "queueing %d bytes", outsize);
outsize = payload_len;
outbuf = gst_buffer_new_and_alloc (outsize);
-
- outdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- memcpy (outdata, payload, outsize);
- gst_buffer_unmap (outbuf, outdata, outsize);
+ gst_buffer_fill (outbuf, 0, payload, outsize);
GST_DEBUG_OBJECT (rtph264depay, "queueing %d bytes", outsize);
outsize = nalu_size + sizeof (sync_bytes);
outbuf = gst_buffer_new_and_alloc (outsize);
- outdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
if (rtph264depay->byte_stream) {
- memcpy (outdata, sync_bytes, sizeof (sync_bytes));
+ memcpy (map.data, sync_bytes, sizeof (sync_bytes));
} else {
- outdata[0] = outdata[1] = 0;
- outdata[2] = nalu_size >> 8;
- outdata[3] = nalu_size & 0xff;
+ map.data[0] = map.data[1] = 0;
+ map.data[2] = nalu_size >> 8;
+ map.data[3] = nalu_size & 0xff;
}
- memcpy (outdata + sizeof (sync_bytes), payload, nalu_size);
- gst_buffer_unmap (outbuf, outdata, outsize);
+ memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
+ gst_buffer_unmap (outbuf, &map);
outbuf = gst_rtp_h264_depay_handle_nal (rtph264depay, outbuf, timestamp,
marker);
GString *sprops;
guint count;
gboolean res;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
sprops = g_string_new ("");
count = 0;
for (walk = payloader->sps; walk; walk = g_list_next (walk)) {
GstBuffer *sps_buf = GST_BUFFER_CAST (walk->data);
- data = gst_buffer_map (sps_buf, &size, NULL, GST_MAP_READ);
- set = g_base64_encode (data, size);
- gst_buffer_unmap (sps_buf, data, size);
+ gst_buffer_map (sps_buf, &map, GST_MAP_READ);
+ set = g_base64_encode (map.data, map.size);
+ gst_buffer_unmap (sps_buf, &map);
g_string_append_printf (sprops, "%s%s", count ? "," : "", set);
g_free (set);
for (walk = payloader->pps; walk; walk = g_list_next (walk)) {
GstBuffer *pps_buf = GST_BUFFER_CAST (walk->data);
- data = gst_buffer_map (pps_buf, &size, NULL, GST_MAP_READ);
- set = g_base64_encode (data, size);
- gst_buffer_unmap (pps_buf, data, size);
+ gst_buffer_map (pps_buf, &map, GST_MAP_READ);
+ set = g_base64_encode (map.data, map.size);
+ gst_buffer_unmap (pps_buf, &map);
g_string_append_printf (sprops, "%s%s", count ? "," : "", set);
g_free (set);
GstRtpH264Pay *rtph264pay;
GstStructure *str;
const GValue *value;
- guint8 *data, *bdata;
- gsize size, bsize;
+ GstMapInfo map;
+ guint8 *data;
+ gsize size;
GstBuffer *buffer;
const gchar *alignment;
buffer = gst_value_get_buffer (value);
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
- data = bdata;
- size = bsize;
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
/* parse the avcC data */
if (size < 7)
data += nal_size;
size -= nal_size;
}
+ gst_buffer_unmap (buffer, &map);
/* and update the caps with the collected data */
if (!gst_rtp_h264_pay_set_sps_pps (basepayload))
goto set_sps_pps_failed;
}
error:
{
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
}
for (i = 0; params[i]; i++) {
gsize nal_len;
+ GstMapInfo map;
guint8 *nalp;
guint save = 0;
gint state = 0;
nal_len = strlen (params[i]);
buf = gst_buffer_new_and_alloc (nal_len);
- nalp = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ nalp = map.data;
nal_len = g_base64_decode_step (params[i], nal_len, nalp, &state, &save);
nal_type = nalp[0];
- gst_buffer_unmap (buf, nalp, nal_len);
+ gst_buffer_unmap (buf, &map);
+ gst_buffer_resize (buf, 0, nal_len);
if (!nal_len) {
gst_buffer_unref (buf);
{
GstFlowReturn ret = GST_FLOW_OK;
GList *walk;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
for (walk = rtph264pay->sps; walk; walk = g_list_next (walk)) {
GstBuffer *sps_buf = GST_BUFFER_CAST (walk->data);
GST_DEBUG_OBJECT (rtph264pay, "inserting SPS in the stream");
/* resend SPS */
- data = gst_buffer_map (sps_buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (sps_buf, &map, GST_MAP_READ);
ret = gst_rtp_h264_pay_payload_nal (basepayload,
- data, size, timestamp, sps_buf, FALSE);
- gst_buffer_unmap (sps_buf, data, size);
+ map.data, map.size, timestamp, sps_buf, FALSE);
+ gst_buffer_unmap (sps_buf, &map);
/* Not critical here; but throw a warning */
if (ret != GST_FLOW_OK)
GST_WARNING ("Problem pushing SPS");
GST_DEBUG_OBJECT (rtph264pay, "inserting PPS in the stream");
/* resend PPS */
- data = gst_buffer_map (pps_buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (pps_buf, &map, GST_MAP_READ);
ret = gst_rtp_h264_pay_payload_nal (basepayload,
- data, size, timestamp, pps_buf, FALSE);
- gst_buffer_unmap (pps_buf, data, size);
+ map.data, map.size, timestamp, pps_buf, FALSE);
+ gst_buffer_unmap (pps_buf, &map);
/* Not critical here; but throw a warning */
if (ret != GST_FLOW_OK)
GST_WARNING ("Problem pushing PPS");
GstFlowReturn ret;
gsize size;
guint nal_len, i;
- guint8 *bdata = NULL;
- gsize bsize;
+ GstMapInfo map;
const guint8 *data, *nal_data;
GstClockTime timestamp;
GArray *nal_queue;
if (!GST_CLOCK_TIME_IS_VALID (timestamp))
timestamp = GST_BUFFER_TIMESTAMP (buffer);
} else {
- bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
- data = bdata;
- size = bsize;
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
timestamp = GST_BUFFER_TIMESTAMP (buffer);
GST_DEBUG_OBJECT (basepayload, "got %" G_GSIZE_FORMAT " bytes", size);
}
gst_adapter_unmap (rtph264pay->adapter);
gst_adapter_flush (rtph264pay->adapter, pushed);
} else {
- gst_buffer_unmap (buffer, bdata, bsize);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
}
GList *packets, *walk;
guint8 end[2];
GstFlowReturn ret = GST_FLOW_OK;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
GstBuffer *buf;
rtpj2kdepay = GST_RTP_J2K_DEPAY (depayload);
if (walk == packets) {
/* first buffer should contain the SOT */
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (size < 12)
+ if (map.size < 12)
goto invalid_tile;
- if (data[0] == 0xff && data[1] == J2K_MARKER_SOT) {
+ if (map.data[0] == 0xff && map.data[1] == J2K_MARKER_SOT) {
guint Psot, nPsot;
if (end[0] == 0xff && end[1] == J2K_MARKER_EOC)
else
nPsot = avail;
- Psot = GST_READ_UINT32_BE (&data[6]);
+ Psot = GST_READ_UINT32_BE (&map.data[6]);
if (Psot != nPsot && Psot != 0) {
/* Psot must match the size of the tile */
GST_DEBUG_OBJECT (rtpj2kdepay, "set Psot from %u to %u", Psot, nPsot);
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
buf = gst_buffer_make_writable (buf);
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
- GST_WRITE_UINT32_BE (&data[6], nPsot);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ GST_WRITE_UINT32_BE (&map.data[6], nPsot);
}
}
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
}
GST_DEBUG_OBJECT (rtpj2kdepay, "append pu packet of size %" G_GSIZE_FORMAT,
invalid_tile:
{
GST_ELEMENT_WARNING (rtpj2kdepay, STREAM, DECODE, ("Invalid tile"), (NULL));
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
gst_adapter_clear (rtpj2kdepay->t_adapter);
rtpj2kdepay->last_tile = -1;
return ret;
#if 0
GstBufferList *list = NULL;
#endif
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint mtu, max_size;
guint offset;
guint end, pos;
pay = GST_RTP_J2K_PAY (basepayload);
mtu = GST_RTP_BASE_PAYLOAD_MTU (pay);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
offset = pos = end = 0;
GST_LOG_OBJECT (pay,
- "got buffer size %" G_GSIZE_FORMAT ", timestamp %" GST_TIME_FORMAT, size,
- GST_TIME_ARGS (timestamp));
+ "got buffer size %" G_GSIZE_FORMAT ", timestamp %" GST_TIME_FORMAT,
+ map.size, GST_TIME_ARGS (timestamp));
/* do some header defaults first */
state.header.tp = 0; /* only progressive scan */
pos = end;
/* exit when finished */
- if (pos == size)
+ if (pos == map.size)
break;
/* scan next packetization unit and fill in the header */
- end = find_pu_end (pay, data, size, pos, &state);
+ end = find_pu_end (pay, map.data, map.size, pos, &state);
} while (TRUE);
while (pu_size > 0) {
else
state.header.MHF = 2;
}
- if (end >= size)
+ if (end >= map.size)
gst_rtp_buffer_set_marker (&rtp, TRUE);
}
#endif
{
/* copy payload */
- memcpy (header + HEADER_SIZE, &data[offset], data_size);
+ memcpy (header + HEADER_SIZE, &map.data[offset], data_size);
gst_rtp_buffer_unmap (&rtp);
ret = gst_rtp_base_payload_push (basepayload, outbuf);
offset += data_size;
}
offset = pos;
- } while (offset < size);
+ } while (offset < map.size);
done:
gst_buffer_unref (buffer);
}
if (frag_offset == 0) {
+ GstMapInfo map;
guint size;
- guint8 *data;
if (rtpjpegdepay->width != width || rtpjpegdepay->height != height) {
GstCaps *outcaps;
}
/* max header length, should be big enough */
outbuf = gst_buffer_new_and_alloc (1000);
- data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- size = MakeHeaders (data, type, width, height, qtable, precision, dri);
- gst_buffer_unmap (outbuf, data, size);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ size = MakeHeaders (map.data, type, width, height, qtable, precision, dri);
+ gst_buffer_unmap (outbuf, &map);
+ gst_buffer_resize (outbuf, 0, size);
GST_DEBUG_OBJECT (rtpjpegdepay, "pushing %u bytes of header", size);
if (gst_rtp_buffer_get_marker (&rtp)) {
guint avail;
guint8 end[2];
- guint8 *data;
+ GstMapInfo map;
/* last buffer take all data out of the adapter */
avail = gst_adapter_available (rtpjpegdepay->adapter);
/* no EOI marker, add one */
outbuf = gst_buffer_new_and_alloc (2);
- data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- data[0] = 0xff;
- data[1] = 0xd9;
- gst_buffer_unmap (outbuf, data, -1);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ map.data[0] = 0xff;
+ map.data[1] = 0xd9;
+ gst_buffer_unmap (outbuf, &map);
gst_adapter_push (rtpjpegdepay->adapter, outbuf);
avail += 2;
RtpQuantTable tables[15] = { {0, NULL}, };
CompInfo info[3] = { {0,}, };
guint quant_data_size;
- guint8 *data, *bdata;
+ GstMapInfo map;
+ guint8 *data;
gsize size;
guint mtu;
guint bytes_left;
pay = GST_RTP_JPEG_PAY (basepayload);
mtu = GST_RTP_BASE_PAYLOAD_MTU (pay);
- data = bdata = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
timestamp = GST_BUFFER_TIMESTAMP (buffer);
offset = 0;
ret = gst_rtp_base_payload_push_list (basepayload, list);
}
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return ret;
unsupported_jpeg:
{
GST_ELEMENT_ERROR (pay, STREAM, FORMAT, ("Unsupported JPEG"), (NULL));
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_NOT_SUPPORTED;
}
no_dimension:
{
GST_ELEMENT_ERROR (pay, STREAM, FORMAT, ("No size given"), (NULL));
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_NOT_NEGOTIATED;
}
invalid_format:
{
/* error was posted */
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
}
invalid_quant:
{
GST_ELEMENT_ERROR (pay, STREAM, FORMAT, ("Invalid quant tables"), (NULL));
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
}
g_value_init (&v, GST_TYPE_BUFFER);
if (gst_value_deserialize (&v, str)) {
GstBuffer *buffer;
+ GstMapInfo map;
guint8 *data;
gsize size;
gint i;
gst_buffer_ref (buffer);
g_value_unset (&v);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
if (size < 2) {
GST_WARNING_OBJECT (depayload, "config too short (%d < 2)",
}
/* ignore remaining bit, we're only interested in full bytes */
- gst_buffer_unmap (buffer, data, size);
+ gst_buffer_resize (buffer, 0, size);
+ gst_buffer_unmap (buffer, &map);
data = NULL;
gst_caps_set_simple (srccaps,
"codec_data", GST_TYPE_BUFFER, buffer, NULL);
bad_config:
if (data)
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
} else {
g_warning ("cannot convert config to buffer");
GstRtpMP4ADepay *rtpmp4adepay;
GstBuffer *outbuf;
GstRTPBuffer rtp = { NULL };
- guint8 *bdata;
+ GstMapInfo map;
rtpmp4adepay = GST_RTP_MP4A_DEPAY (depayload);
GST_LOG_OBJECT (rtpmp4adepay, "have marker and %u available", avail);
outbuf = gst_adapter_take_buffer (rtpmp4adepay->adapter, avail);
- data = bdata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_READ);
+ gst_buffer_map (outbuf, &map, GST_MAP_READ);
+ data = map.data;
/* position in data we are at */
pos = 0;
"possible wrongly encoded packet."));
}
- gst_buffer_unmap (outbuf, bdata, -1);
+ gst_buffer_unmap (outbuf, &map);
gst_buffer_unref (outbuf);
}
gst_rtp_buffer_unmap (&rtp);
{
GST_ELEMENT_WARNING (rtpmp4adepay, STREAM, DECODE,
("Packet did not validate"), ("wrong packet size"));
- gst_buffer_unmap (outbuf, bdata, -1);
+ gst_buffer_unmap (outbuf, &map);
gst_buffer_unref (outbuf);
gst_rtp_buffer_unmap (&rtp);
return NULL;
gst_rtp_mp4a_pay_parse_audio_config (GstRtpMP4APay * rtpmp4apay,
GstBuffer * buffer)
{
+ GstMapInfo map;
guint8 *data;
gsize size;
guint8 objectType;
guint8 samplingIdx;
guint8 channelCfg;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
if (size < 2)
goto too_short;
"objectType: %d, samplingIdx: %d (%d), channelCfg: %d", objectType,
samplingIdx, rtpmp4apay->rate, channelCfg);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return TRUE;
(NULL),
("config string too short, expected 2 bytes, got %" G_GSIZE_FORMAT,
size));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
invalid_object:
{
GST_ELEMENT_ERROR (rtpmp4apay, STREAM, FORMAT,
(NULL), ("invalid object type 0"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
wrong_freq:
{
GST_ELEMENT_ERROR (rtpmp4apay, STREAM, NOT_IMPLEMENTED,
(NULL), ("unsupported frequency index %d", samplingIdx));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
wrong_channels:
{
GST_ELEMENT_ERROR (rtpmp4apay, STREAM, NOT_IMPLEMENTED,
(NULL), ("unsupported number of channels %d, must < 8", channelCfg));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
}
GST_LOG_OBJECT (rtpmp4apay, "got codec_data");
if (G_VALUE_TYPE (codec_data) == GST_TYPE_BUFFER) {
GstBuffer *buffer, *cbuffer;
- guint8 *config;
- guint8 *data;
+ GstMapInfo map;
+ GstMapInfo cmap;
guint i;
- gsize size;
buffer = gst_value_get_buffer (codec_data);
GST_LOG_OBJECT (rtpmp4apay, "configuring codec_data");
if (!res)
goto config_failed;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
/* make the StreamMuxConfig, we need 15 bits for the header */
- cbuffer = gst_buffer_new_and_alloc (size + 2);
- config = gst_buffer_map (cbuffer, NULL, NULL, GST_MAP_WRITE);
+ cbuffer = gst_buffer_new_and_alloc (map.size + 2);
+ gst_buffer_map (cbuffer, &cmap, GST_MAP_WRITE);
/* Create StreamMuxConfig according to ISO/IEC 14496-3:
*
* numProgram == 0 (4 bits)
* numLayer == 0 (3 bits)
*/
- config[0] = 0x40;
- config[1] = 0x00;
+ cmap.data[0] = 0x40;
+ cmap.data[1] = 0x00;
/* append the config bits, shifting them 1 bit left */
- for (i = 0; i < size; i++) {
- config[i + 1] |= ((data[i] & 0x80) >> 7);
- config[i + 2] |= ((data[i] & 0x7f) << 1);
+ for (i = 0; i < map.size; i++) {
+ cmap.data[i + 1] |= ((map.data[i] & 0x80) >> 7);
+ cmap.data[i + 2] |= ((map.data[i] & 0x7f) << 1);
}
- gst_buffer_unmap (cbuffer, config, -1);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (cbuffer, &cmap);
+ gst_buffer_unmap (buffer, &map);
/* now we can configure the buffer */
if (rtpmp4apay->config)
GstFlowReturn ret;
GstBuffer *outbuf;
guint count, mtu;
+ GstMapInfo map;
gsize size;
- guint8 *data, *bdata;
+ guint8 *data;
gboolean fragmented;
GstClockTime timestamp;
rtpmp4apay = GST_RTP_MP4A_PAY (basepayload);
- data = bdata = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ size = map.size;
+ data = map.data;
+
timestamp = GST_BUFFER_TIMESTAMP (buffer);
fragmented = FALSE;
fragmented = TRUE;
}
- gst_buffer_unmap (buffer, bdata, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return ret;
gst_rtp_mp4g_pay_parse_audio_config (GstRtpMP4GPay * rtpmp4gpay,
GstBuffer * buffer)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint8 objectType = 0;
guint8 samplingIdx = 0;
guint8 channelCfg = 0;
GstBitReader br;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- gst_bit_reader_init (&br, data, size);
+ gst_bit_reader_init (&br, map.data, map.size);
/* any object type is fine, we need to copy it to the profile-level-id field. */
if (!gst_bit_reader_get_bits_uint8 (&br, &objectType, 5))
objectType, samplingIdx, rtpmp4gpay->rate, channelCfg,
rtpmp4gpay->frame_len);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return TRUE;
/* ERROR */
{
GST_ELEMENT_ERROR (rtpmp4gpay, STREAM, FORMAT,
(NULL), ("config string too short"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
invalid_object:
{
GST_ELEMENT_ERROR (rtpmp4gpay, STREAM, FORMAT,
(NULL), ("invalid object type"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
wrong_freq:
{
GST_ELEMENT_ERROR (rtpmp4gpay, STREAM, NOT_IMPLEMENTED,
(NULL), ("unsupported frequency index %d", samplingIdx));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
wrong_channels:
{
GST_ELEMENT_ERROR (rtpmp4gpay, STREAM, NOT_IMPLEMENTED,
(NULL), ("unsupported number of channels %d, must < 8", channelCfg));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
}
gst_rtp_mp4g_pay_parse_video_config (GstRtpMP4GPay * rtpmp4gpay,
GstBuffer * buffer)
{
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint32 code;
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
- if (size < 5)
+ if (map.size < 5)
goto too_short;
- code = GST_READ_UINT32_BE (data);
+ code = GST_READ_UINT32_BE (map.data);
g_free (rtpmp4gpay->profile);
if (code == VOS_STARTCODE) {
/* get profile */
- rtpmp4gpay->profile = g_strdup_printf ("%d", (gint) data[4]);
+ rtpmp4gpay->profile = g_strdup_printf ("%d", (gint) map.data[4]);
} else {
GST_ELEMENT_WARNING (rtpmp4gpay, STREAM, FORMAT,
(NULL), ("profile not found in config string, assuming \'1\'"));
GST_LOG_OBJECT (rtpmp4gpay, "profile %s", rtpmp4gpay->profile);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return TRUE;
{
GST_ELEMENT_ERROR (rtpmp4gpay, STREAM, FORMAT,
(NULL), ("config string too short"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
return FALSE;
}
}
}
/* if config string changed or new profile, make new caps */
if (!equal || newprofile) {
- guint8 *bdata;
-
if (enc->config)
gst_buffer_unref (enc->config);
enc->config = gst_buffer_new_and_alloc (i);
- bdata = gst_buffer_map (enc->config, NULL, NULL, GST_MAP_WRITE);
- memcpy (bdata, data, i);
- gst_buffer_unmap (enc->config, bdata, -1);
+
+ gst_buffer_fill (enc->config, 0, data, i);
+
gst_rtp_mp4v_pay_new_caps (enc);
}
*strip = i;
GstRtpMP4VPay *rtpmp4vpay;
GstFlowReturn ret;
guint avail;
- gsize size;
guint packet_len;
- guint8 *data;
+ GstMapInfo map;
+ gsize size;
gboolean flush;
gint strip;
GstClockTime timestamp, duration;
rtpmp4vpay = GST_RTP_MP4V_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ size = map.size;
timestamp = GST_BUFFER_TIMESTAMP (buffer);
duration = GST_BUFFER_DURATION (buffer);
avail = gst_adapter_available (rtpmp4vpay->adapter);
/* depay incomming data and see if we need to start a new RTP
* packet */
- flush = gst_rtp_mp4v_pay_depay_data (rtpmp4vpay, data, size, &strip, &vopi);
- gst_buffer_unmap (buffer, data, -1);
- data = NULL;
+ flush =
+ gst_rtp_mp4v_pay_depay_data (rtpmp4vpay, map.data, size, &strip, &vopi);
+ gst_buffer_unmap (buffer, &map);
if (strip) {
/* strip off config if requested */
rtpmpadepay, GstADUFrame * frame)
{
GstADUFrame *dummy;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
dummy = g_slice_dup (GstADUFrame, frame);
dummy->buffer = gst_buffer_new_and_alloc (dummy->side_info + 4);
- data = gst_buffer_map (dummy->buffer, &size, NULL, GST_MAP_WRITE);
- memset (data, 0, size);
- GST_WRITE_UINT32_BE (data, dummy->header);
- gst_buffer_unmap (dummy->buffer, data, size);
+ gst_buffer_map (dummy->buffer, &map, GST_MAP_WRITE);
+ memset (map.data, 0, map.size);
+ GST_WRITE_UINT32_BE (map.data, dummy->header);
+ gst_buffer_unmap (dummy->buffer, &map);
GST_BUFFER_TIMESTAMP (dummy->buffer) = GST_BUFFER_TIMESTAMP (frame->buffer);
GstADUFrame *frame = NULL;
guint version, layer, channels, size;
guint crc;
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
g_return_val_if_fail (buf != NULL, FALSE);
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
- if (bsize < 6)
+ if (map.size < 6)
goto corrupt_frame;
frame = g_slice_new0 (GstADUFrame);
- frame->header = GST_READ_UINT32_BE (bdata);
+ frame->header = GST_READ_UINT32_BE (map.data);
size = mp3_type_frame_length_from_header (GST_ELEMENT_CAST (rtpmpadepay),
frame->header, &version, &layer, &channels, NULL, NULL, NULL, &crc);
/* backpointer */
if (layer == 3) {
- frame->backpointer = GST_READ_UINT16_BE (bdata + 4);
+ frame->backpointer = GST_READ_UINT16_BE (map.data + 4);
frame->backpointer >>= 7;
GST_LOG_OBJECT (rtpmpadepay, "backpointer: %d", frame->backpointer);
}
frame->data_size = frame->size - 4 - frame->side_info;
/* some size validation checks */
- if (4 + frame->side_info > bsize)
+ if (4 + frame->side_info > map.size)
goto corrupt_frame;
/* ADU data would then extend past MP3 frame,
* even using past byte reservoir */
- if (-frame->backpointer + (gint) (bsize) > frame->size)
+ if (-frame->backpointer + (gint) (map.size) > frame->size)
goto corrupt_frame;
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
/* ok, take buffer and queue */
frame->buffer = buf;
corrupt_frame:
{
GST_DEBUG_OBJECT (rtpmpadepay, "frame is corrupt");
- gst_buffer_unmap (buf, bdata, bsize);
+ gst_buffer_unmap (buf, &map);
gst_buffer_unref (buf);
if (frame)
g_slice_free (GstADUFrame, frame);
GstBuffer * buf)
{
gboolean ret = FALSE;
- guint8 *data;
- gsize size;
+ GstMapInfo map;
guint val, iindex, icc;
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- val = GST_READ_UINT16_BE (data) >> 5;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ val = GST_READ_UINT16_BE (map.data) >> 5;
+ gst_buffer_unmap (buf, &map);
iindex = val >> 3;
icc = val & 0x7;
GstFlowReturn ret = GST_FLOW_OK;
while (1) {
- guint8 *data;
- gsize size;
+ GstMapInfo map;
if (G_UNLIKELY (!rtpmpadepay->cur_adu_frame)) {
rtpmpadepay->cur_adu_frame = rtpmpadepay->adu_frames->head;
gst_byte_writer_set_pos (rtpmpadepay->mp3_frame, 0);
/* bytewriter corresponds to head frame,
* i.e. the header and the side info must match */
- data = gst_buffer_map (head->buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (head->buffer, &map, GST_MAP_READ);
gst_byte_writer_put_data (rtpmpadepay->mp3_frame,
- data, 4 + head->side_info);
- gst_buffer_unmap (head->buffer, data, size);
+ map.data, 4 + head->side_info);
+ gst_buffer_unmap (head->buffer, &map);
}
buf = frame->buffer;
rtpmpadepay->size);
if (rtpmpadepay->offset) {
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
/* no need to position, simply append */
- g_assert (size > rtpmpadepay->offset);
- av = MIN (av, size - rtpmpadepay->offset);
+ g_assert (map.size > rtpmpadepay->offset);
+ av = MIN (av, map.size - rtpmpadepay->offset);
GST_LOG_OBJECT (rtpmpadepay,
"appending %d bytes from ADU frame at offset %d", av,
rtpmpadepay->offset);
gst_byte_writer_put_data (rtpmpadepay->mp3_frame,
- data + rtpmpadepay->offset, av);
+ map.data + rtpmpadepay->offset, av);
rtpmpadepay->offset += av;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
} else {
gint pos, tpos;
gst_byte_writer_set_pos (rtpmpadepay->mp3_frame, pos + av);
} else {
/* position and append */
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
GST_LOG_OBJECT (rtpmpadepay, "adding to current MP3 frame");
gst_byte_writer_set_pos (rtpmpadepay->mp3_frame, tpos);
- av = MIN (av, size - 4 - frame->side_info);
+ av = MIN (av, map.size - 4 - frame->side_info);
gst_byte_writer_put_data (rtpmpadepay->mp3_frame,
- data + 4 + frame->side_info, av);
+ map.data + 4 + frame->side_info, av);
rtpmpadepay->offset += av + 4 + frame->side_info;
- gst_buffer_unmap (buf, data, size);
+ gst_buffer_unmap (buf, &map);
}
}
create_erasure_buffer (GstRtpQCELPDepay * depay)
{
GstBuffer *outbuf;
- guint8 *data;
+ GstMapInfo map;
outbuf = gst_buffer_new_and_alloc (1);
- data = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- data[0] = 14;
- gst_buffer_unmap (outbuf, data, -1);
+ gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
+ map.data[0] = 14;
+ gst_buffer_unmap (outbuf, &map);
return outbuf;
}
if (G_UNLIKELY (!rtpqdm2depay->configured)) {
guint8 *ourdata;
GstBuffer *codecdata;
- guint8 *cdata;
+ GstMapInfo cmap;
GstCaps *caps;
/* First bytes are unknown */
/* Caps */
codecdata = gst_buffer_new_and_alloc (48);
- cdata = gst_buffer_map (codecdata, NULL, NULL, GST_MAP_WRITE);
- memcpy (cdata, headheader, 20);
- memcpy (cdata + 20, ourdata, 28);
- gst_buffer_unmap (codecdata, cdata, -1);
+ gst_buffer_map (codecdata, &cmap, GST_MAP_WRITE);
+ memcpy (cmap.data, headheader, 20);
+ memcpy (cmap.data + 20, ourdata, 28);
+ gst_buffer_unmap (codecdata, &cmap);
caps = gst_caps_new_simple ("audio/x-qdm2",
"samplesize", G_TYPE_INT, 16,
GstRtpSPEEXDepay *rtpspeexdepay;
gint clock_rate, nb_channels;
GstBuffer *buf;
- guint8 *data, *bdata;
+ GstMapInfo map;
+ guint8 *data;
const gchar *params;
GstCaps *srccaps;
gboolean res;
/* construct minimal header and comment packet for the decoder */
buf = gst_buffer_new_and_alloc (80);
- data = bdata = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (buf, &map, GST_MAP_WRITE);
+ data = map.data;
memcpy (data, "Speex ", 8);
data += 8;
memcpy (data, "1.1.12", 7);
GST_WRITE_UINT32_LE (data, 0); /* reserved1 */
data += 4;
GST_WRITE_UINT32_LE (data, 0); /* reserved2 */
- gst_buffer_unmap (buf, bdata, -1);
+ gst_buffer_unmap (buf, &map);
srccaps = gst_caps_new_empty_simple ("audio/x-speex");
res = gst_pad_set_caps (depayload->srcpad, srccaps);
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpspeexdepay), buf);
buf = gst_buffer_new_and_alloc (sizeof (gst_rtp_speex_comment));
- bdata = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
- memcpy (bdata, gst_rtp_speex_comment, sizeof (gst_rtp_speex_comment));
- gst_buffer_unmap (buf, bdata, -1);
+ gst_buffer_fill (buf, 0, gst_rtp_speex_comment,
+ sizeof (gst_rtp_speex_comment));
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpspeexdepay), buf);
{
GstRtpSPEEXPay *rtpspeexpay;
guint payload_len;
- gsize size;
+ GstMapInfo map;
GstBuffer *outbuf;
- guint8 *payload, *data;
+ guint8 *payload;
GstClockTime timestamp, duration;
GstFlowReturn ret;
GstRTPBuffer rtp = { NULL };
rtpspeexpay = GST_RTP_SPEEX_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
switch (rtpspeexpay->packet) {
case 0:
/* ident packet. We need to parse the headers to construct the RTP
* properties. */
- if (!gst_rtp_speex_pay_parse_ident (rtpspeexpay, data, size))
+ if (!gst_rtp_speex_pay_parse_ident (rtpspeexpay, map.data, map.size))
goto parse_error;
ret = GST_FLOW_OK;
duration = GST_BUFFER_DURATION (buffer);
/* FIXME, only one SPEEX frame per RTP packet for now */
- payload_len = size;
+ payload_len = map.size;
outbuf = gst_rtp_buffer_new_allocate (payload_len, 0, 0);
/* FIXME, assert for now */
payload = gst_rtp_buffer_get_payload (&rtp);
/* copy data in payload */
- memcpy (&payload[0], data, size);
+ memcpy (&payload[0], map.data, map.size);
gst_rtp_buffer_unmap (&rtp);
ret = gst_rtp_base_payload_push (basepayload, outbuf);
done:
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
rtpspeexpay->packet++;
{
GST_ELEMENT_ERROR (rtpspeexpay, STREAM, DECODE, (NULL),
("Error parsing first identification packet."));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
}
if (G_UNLIKELY (C)) {
GstCaps *caps;
GstBuffer *codec_data;
+ GstMapInfo cmap;
guint8 res;
- guint8 *cdata;
GST_DEBUG ("Configuration packet");
/* CodecData needs to be 'SEQH' + len (32bit) + data according to
* ffmpeg's libavcodec/svq3.c:svq3_decode_init */
codec_data = gst_buffer_new_and_alloc (payload_len + 6);
- cdata = gst_buffer_map (codec_data, NULL, NULL, GST_MAP_WRITE);
- memcpy (cdata, "SEQH", 4);
- GST_WRITE_UINT32_LE (cdata + 4, payload_len - 2);
- memcpy (cdata + 8, payload + 2, payload_len - 2);
-
- GST_MEMDUMP ("codec_data", cdata, gst_buffer_get_size (codec_data));
-
- gst_buffer_unmap (codec_data, cdata, -1);
+ gst_buffer_map (codec_data, &cmap, GST_MAP_WRITE);
+ memcpy (cmap.data, "SEQH", 4);
+ GST_WRITE_UINT32_LE (cmap.data + 4, payload_len - 2);
+ memcpy (cmap.data + 8, payload + 2, payload_len - 2);
+ GST_MEMDUMP ("codec_data", cmap.data, gst_buffer_get_size (codec_data));
+ gst_buffer_unmap (codec_data, &cmap);
caps = gst_caps_new_simple ("video/x-svq",
"svqversion", G_TYPE_INT, 3,
{
GstBuffer *buf;
guint32 num_headers;
- guint8 *data, *bdata;
+ GstMapInfo map;
+ guint8 *data;
gsize size;
gint i, j;
- data = bdata = gst_buffer_map (confbuf, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (confbuf, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
GST_DEBUG_OBJECT (rtptheoradepay, "config size %" G_GSIZE_FORMAT, size);
for (j = 0; j <= n_headers; j++) {
guint h_size;
- guint8 *odata;
h_size = h_sizes[j];
if (size < h_size) {
h_size);
buf = gst_buffer_new_and_alloc (h_size);
- odata = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
- memcpy (odata, data, h_size);
- gst_buffer_unmap (buf, odata, -1);
+ gst_buffer_fill (buf, 0, data, h_size);
conf->headers = g_list_append (conf->headers, buf);
data += h_size;
size -= h_size;
rtptheoradepay->configs = g_list_append (rtptheoradepay->configs, conf);
}
- gst_buffer_unmap (confbuf, bdata, -1);
+ gst_buffer_unmap (confbuf, &map);
return TRUE;
/* ERRORS */
too_small:
{
GST_DEBUG_OBJECT (rtptheoradepay, "configuration too small");
- gst_buffer_unmap (confbuf, bdata, -1);
+ gst_buffer_unmap (confbuf, &map);
return FALSE;
}
}
guint length)
{
GstBuffer *confbuf;
- guint8 *conf;
+ GstMapInfo map;
if (G_UNLIKELY (size < 4))
return FALSE;
/* transform inline to out-of-band and parse that one */
confbuf = gst_buffer_new_and_alloc (size + 9);
- conf = gst_buffer_map (confbuf, NULL, NULL, GST_MAP_WRITE);
+ gst_buffer_map (confbuf, &map, GST_MAP_WRITE);
/* 1 header */
- GST_WRITE_UINT32_BE (conf, 1);
+ GST_WRITE_UINT32_BE (map.data, 1);
/* write Ident */
- GST_WRITE_UINT24_BE (conf + 4, ident);
+ GST_WRITE_UINT24_BE (map.data + 4, ident);
/* write sort-of-length */
- GST_WRITE_UINT16_BE (conf + 7, length);
+ GST_WRITE_UINT16_BE (map.data + 7, length);
/* copy remainder */
- memcpy (conf + 9, configuration, size);
- gst_buffer_unmap (confbuf, conf, -1);
+ memcpy (map.data + 9, configuration, size);
+ gst_buffer_unmap (confbuf, &map);
return gst_rtp_theora_depay_parse_configuration (rtptheoradepay, confbuf);
}
(payload - to_free) + length, payload - to_free, length));
to_free = NULL;
} else {
- guint8 *odata;
-
outbuf = gst_buffer_new_and_alloc (length);
- odata = gst_buffer_map (outbuf, NULL, NULL, GST_MAP_WRITE);
- memcpy (odata, payload, length);
- gst_buffer_unmap (outbuf, odata, -1);
+ gst_buffer_fill (outbuf, 0, payload, length);
}
if (payload_len > 0 && (payload[0] & 0xC0) == 0x0)
extralen = 1;
for (walk = rtptheorapay->headers; walk; walk = g_list_next (walk)) {
GstBuffer *buf = GST_BUFFER_CAST (walk->data);
+ GstMapInfo map;
guint bsize;
- guint8 *data;
- gsize size;
bsize = gst_buffer_get_size (buf);
length += bsize;
} while (bsize);
}
/* update hash */
- data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
- ident = fnv1_hash_32_update (ident, data, size);
- gst_buffer_unmap (buf, data, -1);
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ ident = fnv1_hash_32_update (ident, map.data, map.size);
+ gst_buffer_unmap (buf, &map);
}
/* packet length is header size + packet length */
/* copy header data */
for (walk = rtptheorapay->headers; walk; walk = g_list_next (walk)) {
GstBuffer *buf = GST_BUFFER_CAST (walk->data);
- guint8 *bdata;
- gsize bsize;
+ GstMapInfo map;
- bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READ);
- memcpy (data, bdata, bsize);
- gst_buffer_unmap (buf, bdata, -1);
- data += bsize;
+ gst_buffer_map (buf, &map, GST_MAP_READ);
+ memcpy (data, map.data, map.size);
+ gst_buffer_unmap (buf, &map);
+ data += map.size;
}
/* serialize to base64 */
{
GstRtpTheoraPay *rtptheorapay;
GstFlowReturn ret;
+ GstMapInfo map;
gsize size;
guint8 *data;
GstClockTime duration, timestamp;
rtptheorapay = GST_RTP_THEORA_PAY (basepayload);
- data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ data = map.data;
+ size = map.size;
duration = GST_BUFFER_DURATION (buffer);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
if (TDT != 0) {
GST_DEBUG_OBJECT (rtptheorapay, "collecting header, buffer %p", buffer);
/* append header to the list of headers */
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
rtptheorapay->headers = g_list_append (rtptheorapay->headers, buffer);
ret = GST_FLOW_OK;
goto done;
ret = gst_rtp_theora_pay_payload_buffer (rtptheorapay, TDT, data, size,
timestamp, duration, 0);
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
done:
{
GST_ELEMENT_WARNING (rtptheorapay, STREAM, DECODE,
("Invalid packet size (%" G_GSIZE_FORMAT " <= 0xffff)", size), (NULL));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
parse_id_failed:
{
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_ERROR;
}
{
GST_ELEMENT_WARNING (rtptheorapay, STREAM, DECODE,
(NULL), ("Ignoring unknown header received"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
{
GST_ELEMENT_WARNING (rtptheorapay, STREAM, DECODE,
(NULL), ("Error initializing header config"));
- gst_buffer_unmap (buffer, data, -1);
+ gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
projects / platform / upstream / gstreamer.git / commitdiff