Download-Tools/mkvtoolnix
1
0
Fork 0
mirror of https://gitlab.com/mbunkus/mkvtoolnix.git synced 2024-12-23 19:31:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed a couple of small memory leaks. Removed the old "duplicate_data_on_add" semantics and replaced it with a "memory_c" class which automatically frees memory if necessary.

Browse Source
This commit is contained in:
Moritz Bunkus 2004-03-22 15:48:08 +00:00
parent 8359e5bf4f
commit 0dc1507fc6
41 changed files with 284 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/input/r_aac.cpp
View File

@ -172,7 +172,8 @@ aac_reader_c::read(generic_packetizer_c *) {
return 0;
}
aacpacketizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
aacpacketizer->process(mem);
bytes_processed += nread;
return EMOREDATA;

3
src/input/r_ac3.cpp
View File

@ -113,7 +113,8 @@ ac3_reader_c::read(generic_packetizer_c *) {
return 0;
}
ac3packetizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
ac3packetizer->process(mem);
bytes_processed += nread;
return EMOREDATA;

17
src/input/r_avi.cpp
View File

@ -547,8 +547,10 @@ avi_reader_c::read(generic_packetizer_c *ptzr) {
debug_leave("AVI_read_frame");
#endif
if (nread < 0) {
vpacketizer->process(old_chunk, old_nread, -1, -1,
memory_c mem(old_chunk, old_nread, true);
vpacketizer->process(mem, -1, -1,
old_key ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
old_chunk = NULL;
mxwarn(PFX "Reading frame number %d resulted in an error. "
"Aborting this track.\n", frames);
frames = maxframes + 1;
@ -569,8 +571,10 @@ avi_reader_c::read(generic_packetizer_c *ptzr) {
}
duration = (int64_t)(1000000000.0 * frames_read / fps);
if (nread > 0) {
vpacketizer->process(old_chunk, old_nread, -1, duration,
memory_c mem(old_chunk, old_nread, true);
vpacketizer->process(mem, -1, duration,
old_key ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
old_chunk = NULL;
if (! last_frame) {
if (old_chunk != NULL)
safefree(old_chunk);
@ -578,7 +582,8 @@ avi_reader_c::read(generic_packetizer_c *ptzr) {
old_key = key;
old_nread = nread;
} else if (nread > 0) {
vpacketizer->process(chunk, nread, -1, duration,
memory_c mem(chunk, nread, false);
vpacketizer->process(mem, -1, duration,
key ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
}
}
@ -617,7 +622,8 @@ avi_reader_c::read(generic_packetizer_c *ptzr) {
debug_leave("aviclasses->Read() audio");
demuxer->frame += blread;
if (result == S_OK) {
demuxer->packetizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
demuxer->packetizer->process(mem);
need_more_data = demuxer->frame < demuxer->maxframes;
} else
demuxer->frame = demuxer->maxframes;
@ -639,7 +645,8 @@ avi_reader_c::read(generic_packetizer_c *ptzr) {
if (nread > 0) {
if (nread >= size)
need_more_data = true;
demuxer->packetizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
demuxer->packetizer->process(mem);
}
#endif

3
src/input/r_dts.cpp
View File

@ -108,7 +108,8 @@ dts_reader_c::read(generic_packetizer_c *) {
return 0;
}
dtspacketizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
dtspacketizer->process(mem);
bytes_processed += nread;
return EMOREDATA;

7
src/input/r_flac.cpp
View File

@ -134,7 +134,6 @@ flac_reader_c::flac_reader_c(track_info_c *nti)
}
packetizer = new flac_packetizer_c(this, sample_rate, channels,
bits_per_sample, buf, block_size, ti);
packetizer->duplicate_data_on_add(false);
safefree(buf);
} catch (error_c &error) {
mxerror(FPFX "could not initialize the FLAC packetizer.\n");
@ -253,9 +252,9 @@ flac_reader_c::read(generic_packetizer_c *) {
packetizer->flush();
return 0;
}
packetizer->process(buf, current_block->len, samples * 1000000000 /
sample_rate, current_block->samples * 1000000000 /
sample_rate);
memory_c mem(buf, current_block->len, true);
packetizer->process(mem, samples * 1000000000 / sample_rate,
current_block->samples * 1000000000 / sample_rate);
samples += current_block->samples;
current_block++;

33
src/input/r_matroska.cpp
View File

@ -186,6 +186,8 @@ kax_reader_c::~kax_reader_c() {
delete saved_l1;
if (in != NULL)
delete in;
if (es != NULL)
delete es;
if (segment != NULL)
delete segment;
}
@ -1790,9 +1792,10 @@ kax_reader_c::read(generic_packetizer_c *) {
for (i = 0; i < (int)block->NumberFrames(); i++) {
DataBuffer &data = block->GetBuffer(i);
memory_c mem((unsigned char *)data.Buffer(), data.Size(),
false);
((passthrough_packetizer_c *)block_track->packetizer)->
process((unsigned char *)data.Buffer(), data.Size(),
last_timecode, block_duration,
process(mem, last_timecode, block_duration,
block_bref, block_fref, duration != NULL);
}
@ -1844,21 +1847,19 @@ kax_reader_c::read(generic_packetizer_c *) {
lines = (char *)safemalloc(re_size + 1);
lines[re_size] = 0;
memcpy(lines, re_buffer, re_size);
block_track->packetizer->process((unsigned char *)lines, 0,
(int64_t)last_timecode,
block_duration,
block_bref,
block_fref);
safefree(lines);
memory_c mem((unsigned char *)lines, 0, true);
block_track->packetizer->
process(mem, (int64_t)last_timecode, block_duration,
block_bref, block_fref);
if (re_modified)
safefree(re_buffer);
}
} else
block_track->packetizer->process(re_buffer, re_size,
(int64_t)last_timecode,
block_duration,
block_bref,
block_fref);
if (re_modified)
safefree(re_buffer);
} else {
memory_c mem(re_buffer, re_size, re_modified);
block_track->packetizer->
process(mem, (int64_t)last_timecode, block_duration,
block_bref, block_fref);
}
}
block_track->previous_timecode = (int64_t)last_timecode;

3
src/input/r_mp3.cpp
View File

@ -126,7 +126,8 @@ mp3_reader_c::read(generic_packetizer_c *) {
return 0;
}
mp3packetizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
mp3packetizer->process(mem);
bytes_processed += nread;
return EMOREDATA;

37
src/input/r_ogm.cpp
View File

@ -345,7 +345,7 @@ ogm_reader_c::~ogm_reader_c() {
delete dmx;
}
safefree(sdemuxers);
ti->private_data = NULL;
delete mm_io;
}
ogm_demuxer_t *
@ -903,16 +903,17 @@ ogm_reader_c::process_page(ogg_page *og) {
if (dmx->units_processed <= dmx->flac_header_packets)
continue;
for (i = 0; i < (int)dmx->nh_packet_data.size(); i++) {
dmx->packetizer->process(dmx->nh_packet_data[i],
dmx->nh_packet_sizes[i], 0);
safefree(dmx->nh_packet_data[i]);
memory_c mem(dmx->nh_packet_data[i], dmx->nh_packet_sizes[i], true);
dmx->packetizer->process(mem, 0);
}
dmx->nh_packet_data.clear();
if (dmx->last_granulepos == -1)
dmx->packetizer->process(op.packet, op.bytes, -1);
else {
dmx->packetizer->process(op.packet, op.bytes, dmx->last_granulepos *
1000000000 / dmx->vorbis_rate);
if (dmx->last_granulepos == -1) {
memory_c mem(op.packet, op.bytes, false);
dmx->packetizer->process(mem, -1);
} else {
memory_c mem(op.packet, op.bytes, false);
dmx->packetizer->process(mem, dmx->last_granulepos * 1000000000 /
dmx->vorbis_rate);
dmx->last_granulepos = ogg_page_granulepos(og);
}
@ -938,8 +939,8 @@ ogm_reader_c::process_page(ogg_page *og) {
((*op.packet & 3) != PACKET_TYPE_COMMENT)) {
if (dmx->stype == OGM_STREAM_TYPE_VIDEO) {
dmx->packetizer->process(&op.packet[hdrlen + 1], op.bytes - 1 - hdrlen,
-1, -1,
memory_c mem(&op.packet[hdrlen + 1], op.bytes - 1 - hdrlen, false);
dmx->packetizer->process(mem, -1, -1,
(*op.packet & PACKET_IS_SYNCPOINT ?
VFT_IFRAME : VFT_PFRAMEAUTOMATIC));
dmx->units_processed += (hdrlen > 0 ? lenbytes : 1);
@ -948,17 +949,19 @@ ogm_reader_c::process_page(ogg_page *og) {
dmx->units_processed++;
if (((op.bytes - 1 - hdrlen) > 2) ||
((op.packet[hdrlen + 1] != ' ') &&
(op.packet[hdrlen + 1] != 0) && !iscr(op.packet[hdrlen + 1])))
dmx->packetizer->process(&op.packet[hdrlen + 1], op.bytes - 1 -
hdrlen, ogg_page_granulepos(og) * 1000000,
(op.packet[hdrlen + 1] != 0) && !iscr(op.packet[hdrlen + 1]))) {
memory_c mem(&op.packet[hdrlen + 1], op.bytes - 1 - hdrlen, false);
dmx->packetizer->process(mem, ogg_page_granulepos(og) * 1000000,
(int64_t)lenbytes * 1000000);
}
} else if (dmx->stype == OGM_STREAM_TYPE_VORBIS) {
dmx->packetizer->process(op.packet, op.bytes);
memory_c mem(op.packet, op.bytes, false);
dmx->packetizer->process(mem);
} else {
dmx->packetizer->process(&op.packet[hdrlen + 1],
op.bytes - 1 - hdrlen);
memory_c mem(&op.packet[hdrlen + 1], op.bytes - 1 - hdrlen, false);
dmx->packetizer->process(mem);
dmx->units_processed += op.bytes - 1;
}
}

17
src/input/r_qtmp4.cpp
View File

@ -878,9 +878,9 @@ qtmp4_reader_c::read(generic_packetizer_c *ptzr) {
dmx->avg_duration = (dmx->avg_duration * dmx->pos + duration) /
(dmx->pos + 1);
dmx->packetizer->process(buffer, frame_size, timecode, duration,
is_keyframe ? VFT_IFRAME :
VFT_PFRAMEAUTOMATIC);
memory_c mem(buffer, frame_size, true);
dmx->packetizer->process(mem, timecode, duration, is_keyframe ?
VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
dmx->pos++;
if (dmx->pos < dmx->chunk_table_len)
@ -926,9 +926,9 @@ qtmp4_reader_c::read(generic_packetizer_c *ptzr) {
return 0;
}
dmx->packetizer->process(buffer, frame_size, timecode, duration,
is_keyframe ? VFT_IFRAME :
VFT_PFRAMEAUTOMATIC);
memory_c mem(buffer, frame_size, true);
dmx->packetizer->process(mem, timecode, duration, is_keyframe ?
VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
dmx->pos++;
if (dmx->pos < dmx->sample_table_len)
chunks_left = true;
@ -1072,8 +1072,6 @@ qtmp4_reader_c::create_packetizer(int64_t tid) {
dmx->v_height, false, ti);
ti->private_data = NULL;
dmx->packetizer->duplicate_data_on_add(false);
mxinfo("+-> Using the video packetizer for track %u (FourCC: %.4s).\n",
dmx->id, dmx->fourcc);
@ -1089,7 +1087,6 @@ qtmp4_reader_c::create_packetizer(int64_t tid) {
ptzr->set_audio_sampling_freq(dmx->a_samplerate);
ptzr->set_audio_channels(dmx->a_channels);
ptzr->set_audio_bit_depth(dmx->a_bitdepth);
ptzr->duplicate_data_on_add(false);
if (verbose)
mxinfo("+-> Using generic audio output module for stream "
@ -1112,7 +1109,6 @@ qtmp4_reader_c::create_packetizer(int64_t tid) {
dmx->packetizer = new aac_packetizer_c(this, AAC_ID_MPEG4, profile,
sample_rate, channels, ti,
false, true);
dmx->packetizer->duplicate_data_on_add(false);
if (sbraac)
dmx->packetizer->
set_audio_output_sampling_freq(output_sample_rate);
@ -1130,7 +1126,6 @@ qtmp4_reader_c::create_packetizer(int64_t tid) {
dmx->a_channels, dmx->a_bitdepth, ti,
(dmx->a_bitdepth > 8) &&
(dmx->fourcc[0] == 't'));
dmx->packetizer->duplicate_data_on_add(false);
if (verbose)
mxinfo("+-> Using PCM output module for stream %u.\n", dmx->id);

70
src/input/r_real.cpp
View File

@ -261,7 +261,6 @@ real_reader_c::create_packetizer(int64_t tid) {
int i;
real_demuxer_t *dmx;
rmff_track_t *track;
bool duplicate_data;
dmx = find_demuxer(tid);
if (dmx == NULL)
@ -272,7 +271,6 @@ real_reader_c::create_packetizer(int64_t tid) {
ti->id = track->id;
ti->private_data = dmx->private_data;
ti->private_size = dmx->private_size;
duplicate_data = false;
if (track->type == RMFF_TRACK_TYPE_VIDEO) {
char buffer[20];
@ -369,7 +367,6 @@ real_reader_c::create_packetizer(int64_t tid) {
"for this input file if the file actually contains SBR AAC. "
"The file will be muxed in the WRONG way otherwise. Also "
"read mkvmerge's documentation.\n", track->id);
duplicate_data = true;
} else {
ptzr = new passthrough_packetizer_c(this, ti);
@ -392,8 +389,6 @@ real_reader_c::create_packetizer(int64_t tid) {
"%u (FourCC: %s).\n", track->id, dmx->fourcc);
}
}
dmx->packetizer->duplicate_data_on_add(duplicate_data);
}
}
@ -468,12 +463,12 @@ real_reader_c::read(generic_packetizer_c *) {
}
chunk = (unsigned char *)safemalloc(size);
memory_c mem(chunk, size, true);
frame = rmff_read_next_frame(file, chunk);
if (frame == NULL) {
if (file->num_packets_read < file->num_packets_in_chunk)
mxwarn(PFX "%s: File contains fewer frames than expected or is "
"corrupt after frame %u.\n", ti->fname, file->num_packets_read);
safefree(chunk);
return finish();
}
@ -484,15 +479,14 @@ real_reader_c::read(generic_packetizer_c *) {
return EMOREDATA;
}
if (dmx->track->type == RMFF_TRACK_TYPE_VIDEO) {
assemble_packet(dmx, chunk, size, timecode, (frame->flags & 2) == 2);
safefree(chunk);
if (dmx->track->type == RMFF_TRACK_TYPE_VIDEO)
assemble_video_packet(dmx, mem, timecode, (frame->flags & 2) == 2);
} else if (dmx->is_aac)
deliver_aac_frames(dmx, chunk, size);
else if (dmx->is_aac)
deliver_aac_frames(dmx, mem);
else
queue_audio_frames(dmx, chunk, size, timecode, frame->flags);
queue_audio_frames(dmx, mem, timecode, frame->flags);
rmff_release_frame(frame);
@ -501,32 +495,31 @@ real_reader_c::read(generic_packetizer_c *) {
void
real_reader_c::queue_one_audio_frame(real_demuxer_t *dmx,
unsigned char *chunk,
uint32_t length,
memory_c &mem,
uint64_t timecode,
uint32_t flags) {
rv_segment_t segment;
segment.data = chunk;
segment.size = length;
segment.data = mem.data;
segment.size = mem.size;
mem.lock();
segment.offset = flags;
dmx->segments->push_back(segment);
dmx->c_timecode = timecode;
mxverb(2, "enqueueing one for %u/'%s' length %u timecode %llu flags "
"0x%08x\n", dmx->track->id, ti->fname, length, timecode, flags);
"0x%08x\n", dmx->track->id, ti->fname, mem.size, timecode, flags);
}
void
real_reader_c::queue_audio_frames(real_demuxer_t *dmx,
unsigned char *chunk,
uint32_t length,
memory_c &mem,
uint64_t timecode,
uint32_t flags) {
// Enqueue the packets if no packets are in the queue or if the current
// packet's timecode is the same as the timecode of those before.
if ((dmx->segments->size() == 0) ||
(dmx->c_timecode == timecode)) {
queue_one_audio_frame(dmx, chunk, length, timecode, flags);
queue_one_audio_frame(dmx, mem, timecode, flags);
return;
}
@ -534,11 +527,12 @@ real_reader_c::queue_audio_frames(real_demuxer_t *dmx,
deliver_audio_frames(dmx, (timecode - dmx->c_timecode) /
dmx->segments->size());
// Enqueue this packet.
queue_one_audio_frame(dmx, chunk, length, timecode, flags);
queue_one_audio_frame(dmx, mem, timecode, flags);
}
void
real_reader_c::deliver_audio_frames(real_demuxer_t *dmx, uint64_t duration) {
real_reader_c::deliver_audio_frames(real_demuxer_t *dmx,
uint64_t duration) {
uint32_t i;
rv_segment_t segment;
@ -550,8 +544,8 @@ real_reader_c::deliver_audio_frames(real_demuxer_t *dmx, uint64_t duration) {
mxverb(2, "delivering audio for %u/'%s' length %llu timecode %llu flags "
"0x%08x duration %llu\n", dmx->track->id, ti->fname, segment.size,
dmx->c_timecode, (uint32_t)segment.offset, duration);
dmx->packetizer->process(segment.data, segment.size,
dmx->c_timecode, duration,
memory_c mem(segment.data, segment.size, true);
dmx->packetizer->process(mem, dmx->c_timecode, duration,
(segment.offset & 2) == 2 ? -1 :
dmx->c_reftimecode);
if ((segment.offset & 2) == 2)
@ -563,14 +557,16 @@ real_reader_c::deliver_audio_frames(real_demuxer_t *dmx, uint64_t duration) {
void
real_reader_c::deliver_aac_frames(real_demuxer_t *dmx,
unsigned char *chunk,
uint32_t length) {
memory_c &mem) {
uint32_t num_sub_packets, data_idx, i, sub_length, len_check;
uint32_t length;
unsigned char *chunk;
chunk = mem.data;
length = mem.size;
if (length < 2) {
mxwarn(PFX "Short AAC audio packet for track ID %u of "
"'%s' (length: %u < 2)\n", dmx->track->id, ti->fname, length);
safefree(chunk);
return;
}
num_sub_packets = chunk[1] >> 4;
@ -579,7 +575,6 @@ real_reader_c::deliver_aac_frames(real_demuxer_t *dmx,
mxwarn(PFX "Short AAC audio packet for track ID %u of "
"'%s' (length: %u < %u)\n", dmx->track->id, ti->fname, length,
2 + num_sub_packets * 2);
safefree(chunk);
return;
}
len_check = 2 + num_sub_packets * 2;
@ -592,16 +587,15 @@ real_reader_c::deliver_aac_frames(real_demuxer_t *dmx,
mxwarn(PFX "Inconsistent AAC audio packet for track ID %u of "
"'%s' (length: %u != len_check %u)\n", dmx->track->id, ti->fname,
length, len_check);
safefree(chunk);
return;
}
data_idx = 2 + num_sub_packets * 2;
for (i = 0; i < num_sub_packets; i++) {
sub_length = get_uint16_be(&chunk[2 + i * 2]);
dmx->packetizer->process(&chunk[data_idx], sub_length);
memory_c mem(&chunk[data_idx], sub_length, false);
dmx->packetizer->process(mem);
data_idx += sub_length;
}
safefree(chunk);
}
// }}}
@ -735,7 +729,8 @@ real_reader_c::deliver_segments(real_demuxer_t *dmx,
ptr += segment->size;
}
dmx->packetizer->process(buffer, len, timecode, -1,
memory_c mem(buffer, len, true);
dmx->packetizer->process(mem, timecode, -1,
dmx->c_keyframe ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC);
for (i = 0; i < dmx->segments->size(); i++)
@ -748,14 +743,13 @@ real_reader_c::deliver_segments(real_demuxer_t *dmx,
// {{{ FUNCTSION real_reader_c::assemble_packet()
void
real_reader_c::assemble_packet(real_demuxer_t *dmx,
unsigned char *p,
int size,
int64_t timecode,
bool keyframe) {
real_reader_c::assemble_video_packet(real_demuxer_t *dmx,
memory_c &mem,
int64_t timecode,
bool keyframe) {
uint32_t vpkg_header, vpkg_length, vpkg_offset, vpkg_subseq, vpkg_seqnum;
uint32_t len;
byte_cursor_c bc(p, size);
byte_cursor_c bc(mem.data, mem.size);
rv_segment_t segment;
int64_t this_timecode;

17
src/input/r_real.h
View File

@ -90,8 +90,8 @@ protected:
virtual void create_packetizers();
virtual void create_packetizer(int64_t tid);
virtual real_demuxer_t *find_demuxer(int id);
virtual void assemble_packet(real_demuxer_t *dmx, unsigned char *p, int size,
int64_t timecode, bool keyframe);
virtual void assemble_video_packet(real_demuxer_t *dmx, memory_c &mem,
int64_t timecode, bool keyframe);
virtual void deliver_segments(real_demuxer_t *dmx, int64_t timecode);
virtual int finish();
virtual bool get_rv_dimensions(unsigned char *buf, int size, uint32_t &width,
@ -100,14 +100,11 @@ protected:
int size);
virtual void get_information_from_data();
virtual void flush_packetizers();
virtual void deliver_aac_frames(real_demuxer_t *dmx, unsigned char *chunk,
uint32_t length);
virtual void queue_audio_frames(real_demuxer_t *dmx, unsigned char *chunk,
uint32_t length, uint64_t timecode,
uint32_t flags);
virtual void queue_one_audio_frame(real_demuxer_t *dmx, unsigned char *chunk,
uint32_t length, uint64_t timecode,
uint32_t flags);
virtual void deliver_aac_frames(real_demuxer_t *dmx, memory_c &mem);
virtual void queue_audio_frames(real_demuxer_t *dmx, memory_c &mem,
uint64_t timecode, uint32_t flags);
virtual void queue_one_audio_frame(real_demuxer_t *dmx, memory_c &mem,
uint64_t timecode, uint32_t flags);
virtual void deliver_audio_frames(real_demuxer_t *dmx, uint64_t duration);
};

1
src/input/r_srt.cpp
View File

@ -92,6 +92,7 @@ srt_reader_c::srt_reader_c(track_info_c *nti)
srt_reader_c::~srt_reader_c() {
if (textsubs_packetizer != NULL)
delete textsubs_packetizer;
delete mm_io;
}
#define STATE_INITIAL 0

6
src/input/r_ssa.cpp
View File

@ -76,6 +76,7 @@ ssa_reader_c::ssa_reader_c(track_info_c *nti)
is_ass = false;
section = 0;
act_wchar = 0;
try {
mm_io = new mm_text_io_c(ti->fname);
@ -153,6 +154,7 @@ ssa_reader_c::ssa_reader_c(track_info_c *nti)
ssa_reader_c::~ssa_reader_c() {
if (textsubs_packetizer != NULL)
delete textsubs_packetizer;
delete mm_io;
}
string
@ -292,8 +294,8 @@ ssa_reader_c::read(generic_packetizer_c *) {
// Let the packetizer handle this line.
mxprints(buffer, "%d", clines[i].num);
line = string(buffer) + string(clines[i].line);
textsubs_packetizer->process((unsigned char *)line.c_str(), 0,
clines[i].start,
memory_c mem((unsigned char *)line.c_str(), 0, false);
textsubs_packetizer->process(mem, clines[i].start,
clines[i].end - clines[i].start);
safefree(clines[i].line);
}

5
src/input/r_vobsub.cpp
View File

@ -381,9 +381,8 @@ vobsub_reader_c::read(generic_packetizer_c *ptzr) {
(uint32_t)(track->positions[i] & 0xffffffff),
track->timecodes[i], ARG_TIMECODE_NS(track->timecodes[i]),
track->durations[i]);
track->packetizer->process(data, track->sizes[i], track->timecodes[i],
track->durations[i]);
safefree(data);
memory_c mem(data, track->sizes[i], true);
track->packetizer->process(mem, track->timecodes[i], track->durations[i]);
track->idx++;
if (track->idx >= track->sizes.size()) {

6
src/input/r_wav.cpp
View File

@ -184,7 +184,8 @@ wav_reader_c::read(generic_packetizer_c *) {
return 0;
}
pcmpacketizer->process(chunk, nread);
memory_c mem(chunk, nread, false);
pcmpacketizer->process(mem);
bytes_processed += nread;
@ -221,7 +222,8 @@ wav_reader_c::read(generic_packetizer_c *) {
erlen = words * 7 * sizeof(short);
}
dtspacketizer->process((unsigned char *) (buf[cur_buf]), erlen);
memory_c mem((unsigned char *)buf[cur_buf], erlen, false);
dtspacketizer->process(mem);
bytes_processed += rlen;

5
src/input/subtitles.cpp
View File

@ -133,9 +133,8 @@ void subtitles_c::process(textsubs_packetizer_c *p) {
sub_t *current;
while ((current = get_next()) != NULL) {
p->process((unsigned char *)current->subs, 0, current->start,
current->end - current->start);
safefree(current->subs);
memory_c mem((unsigned char *)current->subs, 0, true);
p->process(mem, current->start, current->end - current->start);
safefree(current);
}
}

6
src/mkvmerge.cpp
View File

@ -2055,8 +2055,11 @@ parse_args(int argc,
file->ti = ti;
files.push_back(file);
} else
} else {
delete ti;
safefree(file->name);
safefree(file);
}
ti = new track_info_c;
}
@ -2269,6 +2272,7 @@ cleanup() {
while (files.size()) {
file = files[files.size() - 1];
delete file->ti;
safefree(file->name);
safefree(file);
files.pop_back();
}

16
src/output/p_aac.cpp
View File

@ -53,7 +53,6 @@ aac_packetizer_c::aac_packetizer_c(generic_reader_c *nreader,
set_track_type(track_audio);
set_track_default_duration((int64_t)(1024 * 1000000000.0 * ti->async.linear /
samples_per_sec));
duplicate_data_on_add(headerless);
}
aac_packetizer_c::~aac_packetizer_c() {
@ -129,7 +128,8 @@ aac_packetizer_c::get_aac_packet(unsigned long *header,
return buf;
}
void aac_packetizer_c::set_headers() {
void
aac_packetizer_c::set_headers() {
if (id == AAC_ID_MPEG4) {
if (profile == AAC_PROFILE_MAIN)
set_codec_id(MKV_A_AAC_4MAIN);
@ -162,8 +162,7 @@ void aac_packetizer_c::set_headers() {
}
int
aac_packetizer_c::process(unsigned char *buf,
int size,
aac_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -191,20 +190,20 @@ aac_packetizer_c::process(unsigned char *buf,
return EMOREDATA;
}
while (needs_positive_displacement(duration)) {
add_packet(buf, size, my_timecode + ti->async.displacement, duration);
add_packet(mem, my_timecode + ti->async.displacement, duration);
displace(duration);
}
my_timecode = (int64_t)((my_timecode + ti->async.displacement) *
ti->async.linear);
add_packet(buf, size, my_timecode, duration);
add_packet(mem, my_timecode, duration);
debug_leave("aac_packetizer_c::process");
return EMOREDATA;
}
byte_buffer.add(buf, size);
byte_buffer.add(mem.data, mem.size);
while ((packet = get_aac_packet(&header, &aacheader)) != NULL) {
if (timecode == -1)
my_timecode = (int64_t)(1024 * 1000000000.0 * packetno /
@ -212,7 +211,8 @@ aac_packetizer_c::process(unsigned char *buf,
else
my_timecode = timecode + ti->async.displacement;
my_timecode = (int64_t)(my_timecode * ti->async.linear);
add_packet(packet, aacheader.data_byte_size, my_timecode,
memory_c mem(packet, aacheader.data_byte_size, true);
add_packet(mem, my_timecode,
(int64_t)(1024 * 1000000000.0 *
ti->async.linear / samples_per_sec));
packetno++;

2
src/output/p_aac.h
View File

@ -52,7 +52,7 @@ public:
bool nheaderless = false) throw (error_c);
virtual ~aac_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

9
src/output/p_ac3.cpp
View File

@ -48,7 +48,6 @@ ac3_packetizer_c::ac3_packetizer_c(generic_reader_c *nreader,
if (use_durations)
set_track_default_duration((int64_t)(1536000000000.0 *ti->async.linear /
samples_per_sec));
duplicate_data_on_add(false);
}
ac3_packetizer_c::~ac3_packetizer_c() {
@ -130,8 +129,7 @@ ac3_packetizer_c::set_headers() {
}
int
ac3_packetizer_c::process(unsigned char *buf,
int size,
ac3_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -143,7 +141,7 @@ ac3_packetizer_c::process(unsigned char *buf,
debug_enter("ac3_packetizer_c::process");
add_to_buffer(buf, size);
add_to_buffer(mem.data, mem.size);
while ((packet = get_ac3_packet(&header, &ac3header)) != NULL) {
if (timecode == -1)
my_timecode = (int64_t)(1000000000.0 * packetno * 1536 /
@ -151,7 +149,8 @@ ac3_packetizer_c::process(unsigned char *buf,
else
my_timecode = timecode + ti->async.displacement;
my_timecode = (int64_t)(my_timecode * ti->async.linear);
add_packet(packet, ac3header.bytes, my_timecode,
memory_c mem(packet, ac3header.bytes, true);
add_packet(mem, my_timecode,
(int64_t)(1000000000.0 * 1536 * ti->async.linear /
samples_per_sec));
packetno++;

2
src/output/p_ac3.h
View File

@ -41,7 +41,7 @@ public:
throw (error_c);
virtual ~ac3_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

11
src/output/p_dts.cpp
View File

@ -102,7 +102,6 @@ dts_packetizer_c::dts_packetizer_c(generic_reader_c *nreader,
last_header = dtsheader;
set_track_type(track_audio);
duplicate_data_on_add(false);
}
dts_packetizer_c::~dts_packetizer_c() {
@ -222,8 +221,7 @@ dts_packetizer_c::set_headers() {
}
int
dts_packetizer_c::process(unsigned char *buf,
int size,
dts_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -236,7 +234,7 @@ dts_packetizer_c::process(unsigned char *buf,
if (timecode != -1)
my_timecode = timecode;
add_to_buffer(buf, size);
add_to_buffer(mem.data, mem.size);
dts_header_t dtsheader;
unsigned char *packet;
@ -250,8 +248,9 @@ dts_packetizer_c::process(unsigned char *buf,
else
my_timecode = timecode + ti->async.displacement;
my_timecode = (int64_t)(my_timecode * ti->async.linear);
add_packet(packet, dtsheader.frame_byte_size, my_timecode,
(int64_t)(packet_len_in_ns * ti->async.linear));
memory_c mem(packet, dtsheader.frame_byte_size, true);
add_packet(mem, my_timecode, (int64_t)(packet_len_in_ns *
ti->async.linear));
bytes_written += dtsheader.frame_byte_size;
samples_written += get_dts_packet_length_in_core_samples(&dtsheader);

2
src/output/p_dts.h
View File

@ -45,7 +45,7 @@ public:
track_info_c *nti) throw (error_c);
virtual ~dts_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

5
src/output/p_flac.cpp
View File

@ -86,8 +86,7 @@ flac_packetizer_c::set_headers() {
}
int
flac_packetizer_c::process(unsigned char *data,
int size,
flac_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -96,7 +95,7 @@ flac_packetizer_c::process(unsigned char *data,
if (timecode == -1)
timecode = last_timecode;
last_timecode = timecode;
add_packet(data, size, timecode, 0);
add_packet(mem, timecode, 0);
debug_leave("flac_packetizer_c::process");
return EMOREDATA;

2
src/output/p_flac.h
View File

@ -43,7 +43,7 @@ public:
track_info_c *nti) throw (error_c);
virtual ~flac_packetizer_c();
virtual int process(unsigned char *data, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

9
src/output/p_mp3.cpp
View File

@ -47,7 +47,6 @@ mp3_packetizer_c::mp3_packetizer_c(generic_reader_c *nreader,
set_track_type(track_audio);
set_track_default_duration((int64_t)(1152000000000.0 * ti->async.linear /
samples_per_sec));
duplicate_data_on_add(false);
}
mp3_packetizer_c::~mp3_packetizer_c() {
@ -148,8 +147,7 @@ mp3_packetizer_c::set_headers() {
}
int
mp3_packetizer_c::process(unsigned char *buf,
int size,
mp3_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -160,7 +158,7 @@ mp3_packetizer_c::process(unsigned char *buf,
debug_enter("mp3_packetizer_c::process");
byte_buffer.add(buf, size);
byte_buffer.add(mem.data, mem.size);
while ((packet = get_mp3_packet(&mp3header)) != NULL) {
#ifdef DEBUG
dump_packet(packet, mp3header.framesize);
@ -171,7 +169,8 @@ mp3_packetizer_c::process(unsigned char *buf,
else
my_timecode = timecode + ti->async.displacement;
my_timecode = (int64_t)(my_timecode * ti->async.linear);
add_packet(packet, mp3header.framesize, my_timecode,
memory_c mem(packet, mp3header.framesize, true);
add_packet(mem, my_timecode,
(int64_t)(1000000000.0 * spf * ti->async.linear /
samples_per_sec));
packetno++;

2
src/output/p_mp3.h
View File

@ -42,7 +42,7 @@ public:
throw (error_c);
virtual ~mp3_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

22
src/output/p_passthrough.cpp
View File

@ -37,6 +37,7 @@ passthrough_packetizer_c::passthrough_packetizer_c(generic_reader_c *nreader,
generic_packetizer_c(nreader, nti) {
packets_processed = 0;
bytes_processed = 0;
sync_to_keyframe = false;
}
void
@ -45,18 +46,16 @@ passthrough_packetizer_c::set_headers() {
}
int
passthrough_packetizer_c::process(unsigned char *buf,
int size,
passthrough_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t duration,
int64_t bref,
int64_t fref) {
return process(buf, size, timecode, duration, bref, fref, false);
return process(mem, timecode, duration, bref, fref, false);
}
int
passthrough_packetizer_c::process(unsigned char *buf,
int size,
passthrough_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t duration,
int64_t bref,
@ -65,7 +64,7 @@ passthrough_packetizer_c::process(unsigned char *buf,
debug_enter("passthrough_packetizer_c::process");
packets_processed++;
bytes_processed += size;
bytes_processed += mem.size;
if ((duration > 0) && needs_negative_displacement(duration)) {
displace(-duration);
sync_to_keyframe = true;
@ -76,18 +75,15 @@ passthrough_packetizer_c::process(unsigned char *buf,
// Not implemented yet.
}
while ((duration > 0) && needs_positive_displacement(duration)) {
add_packet(buf, size,
add_packet(mem,
(int64_t)((timecode + ti->async.displacement) *
ti->async.linear),
duration, duration_mandatory, bref, fref, -1, cp_yes);
duration, duration_mandatory, bref, fref);
displace(duration);
}
if (sync_to_keyframe && (bref != -1)) {
if (!duplicate_data)
safefree(buf);
if (sync_to_keyframe && (bref != -1))
return EMOREDATA;
}
sync_to_keyframe = false;
timecode = (int64_t)((timecode + ti->async.displacement) * ti->async.linear);
duration = (int64_t)(duration * ti->async.linear);
@ -95,7 +91,7 @@ passthrough_packetizer_c::process(unsigned char *buf,
bref = (int64_t)((bref + ti->async.displacement) * ti->async.linear);
if (fref >= 0)
fref = (int64_t)((fref + ti->async.displacement) * ti->async.linear);
add_packet(buf, size, timecode, duration, duration_mandatory, bref, fref);
add_packet(mem, timecode, duration, duration_mandatory, bref, fref);
debug_leave("passthrough_packetizer_c::process");
return EMOREDATA;

4
src/output/p_passthrough.h
View File

@ -35,10 +35,10 @@ public:
passthrough_packetizer_c(generic_reader_c *nreader, track_info_c *nti)
throw (error_c);
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t duration = -1, int64_t bref = -1,
int64_t fref = -1);
virtual int process(unsigned char *buf, int size, int64_t timecode,
virtual int process(memory_c &mem, int64_t timecode,
int64_t duration, int64_t bref, int64_t fref,
bool duration_mandatory);
virtual void set_headers();

28
src/output/p_pcm.cpp
View File

@ -80,8 +80,7 @@ pcm_packetizer_c::set_headers() {
}
int
pcm_packetizer_c::process(unsigned char *buf,
int size,
pcm_packetizer_c::process(memory_c &mem,
int64_t,
int64_t,
int64_t,
@ -107,24 +106,22 @@ pcm_packetizer_c::process(unsigned char *buf,
}
if (skip_bytes) {
if (skip_bytes > size) {
skip_bytes -= size;
if (skip_bytes > mem.size) {
skip_bytes -= mem.size;
return EMOREDATA;
}
size -= skip_bytes;
new_buf = &buf[skip_bytes];
mem.size -= skip_bytes;
new_buf = &mem.data[skip_bytes];
skip_bytes = 0;
} else
new_buf = buf;
new_buf = mem.data;
buffer.add(new_buf, size);
if (!duplicate_data)
safefree(buf);
buffer.add(new_buf, mem.size);
while (buffer.get_size() >= packet_size) {
add_packet(buffer.get_buffer(), packet_size, bytes_output * 1000000000 /
bps, packet_size * 1000000000 / bps, false, -1, -1, -1,
cp_yes);
memory_c mem(buffer.get_buffer(), packet_size, false);
add_packet(mem, bytes_output * 1000000000 / bps, packet_size * 1000000000 /
bps);
buffer.remove(packet_size);
bytes_output += packet_size;
}
@ -140,8 +137,9 @@ pcm_packetizer_c::flush() {
size = buffer.get_size();
if (size > 0) {
add_packet(buffer.get_buffer(), size, bytes_output * 1000000000 /
bps, size * 1000000000 / bps, false, -1, -1, -1, cp_yes);
memory_c mem(buffer.get_buffer(), size, false);
add_packet(mem, bytes_output * 1000000000 / bps,
size * 1000000000 / bps);
bytes_output += size;
buffer.remove(size);
}

2
src/output/p_pcm.h
View File

@ -42,7 +42,7 @@ public:
throw (error_c);
virtual ~pcm_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

23
src/output/p_textsubs.cpp
View File

@ -72,8 +72,7 @@ textsubs_packetizer_c::set_headers() {
}
int
textsubs_packetizer_c::process(unsigned char *_subs,
int,
textsubs_packetizer_c::process(memory_c &mem,
int64_t start,
int64_t length,
int64_t,
@ -101,7 +100,7 @@ textsubs_packetizer_c::process(unsigned char *_subs,
}
// Count the number of lines.
idx1 = (char *)_subs;
idx1 = (char *)mem.data;
subs = NULL;
num_newlines = 0;
while (*idx1 != 0) {
@ -109,10 +108,10 @@ textsubs_packetizer_c::process(unsigned char *_subs,
num_newlines++;
idx1++;
}
subs = (char *)safemalloc(strlen((char *)_subs) + num_newlines * 2 + 1);
subs = (char *)safemalloc(strlen((char *)mem.data) + num_newlines * 2 + 1);
// Unify the new lines into DOS style newlines.
idx1 = (char *)_subs;
idx1 = (char *)mem.data;
idx2 = subs;
while (*idx1 != 0) {
if (*idx1 == '\n') {
@ -136,13 +135,13 @@ textsubs_packetizer_c::process(unsigned char *_subs,
if (recode) {
utf8_subs = to_utf8(cc_utf8, subs);
add_packet((unsigned char *)utf8_subs, strlen(utf8_subs), start, length,
true);
safefree(utf8_subs);
} else
add_packet((unsigned char *)subs, strlen(subs), start, length, true);
safefree(subs);
safefree(subs);
memory_c mem((unsigned char *)utf8_subs, strlen(utf8_subs), true);
add_packet(mem, start, length, true);
} else {
memory_c mem((unsigned char *)subs, strlen(subs), true);
add_packet(mem, start, length, true);
}
return EMOREDATA;
}

2
src/output/p_textsubs.h
View File

@ -42,7 +42,7 @@ public:
throw (error_c);
virtual ~textsubs_packetizer_c();
virtual int process(unsigned char *_subs, int size, int64_t start = -1,
virtual int process(memory_c &mem, int64_t start = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

39
src/output/p_video.cpp
View File

@ -126,8 +126,7 @@ video_packetizer_c::set_headers() {
// fref > 0: B frame with given forward reference (absolute reference,
// not relative!)
int
video_packetizer_c::process(unsigned char *buf,
int size,
video_packetizer_c::process(memory_c &mem,
int64_t old_timecode,
int64_t duration,
int64_t bref,
@ -139,7 +138,7 @@ video_packetizer_c::process(unsigned char *buf,
debug_enter("video_packetizer_c::process");
if (hack_engaged(ENGAGE_NATIVE_BFRAMES) && is_mpeg4 && (fps != 0.0)) {
find_mpeg4_frame_types(buf, size, frames);
find_mpeg4_frame_types(mem.data, mem.size, frames);
for (i = 0; i < frames.size(); i++) {
if ((frames[i].type == 'I') ||
((frames[i].type != 'B') && (fref_frame.type != '?')))
@ -159,7 +158,7 @@ video_packetizer_c::process(unsigned char *buf,
frames_output++;
frames[i].timecode = timecode;
frames[i].duration = duration;
frames[i].data = (unsigned char *)safememdup(&buf[frames[i].pos],
frames[i].data = (unsigned char *)safememdup(&mem.data[frames[i].pos],
frames[i].size);
if (frames[i].type == 'I') {
@ -167,8 +166,8 @@ video_packetizer_c::process(unsigned char *buf,
frames[i].fref = -1;
if (bref_frame.type == '?') {
bref_frame = frames[i];
add_packet(frames[i].data, frames[i].size, frames[i].timecode,
frames[i].duration, false, -1, -1, -1, cp_no);
memory_c mem(frames[i].data, frames[i].size, false);
add_packet(mem, frames[i].timecode, frames[i].duration);
} else
fref_frame = frames[i];
@ -196,9 +195,6 @@ video_packetizer_c::process(unsigned char *buf,
debug_leave("video_packetizer_c::process");
if (!duplicate_data)
safefree(buf);
return EMOREDATA;
}
@ -215,12 +211,12 @@ video_packetizer_c::process(unsigned char *buf,
if (bref == VFT_IFRAME) {
// Add a key frame and save its timecode so that we can reference it later.
add_packet(buf, size, timecode, duration);
add_packet(mem, timecode, duration);
ref_timecode = timecode;
} else {
// P or B frame. Use our last timecode if the bref is -2, or the provided
// one otherwise. The forward ref is always taken from the reader.
add_packet(buf, size, timecode, duration, false,
add_packet(mem, timecode, duration, false,
bref == VFT_PFRAMEAUTOMATIC ? ref_timecode : bref, fref);
if (fref == VFT_NOBFRAME)
ref_timecode = timecode;
@ -335,8 +331,9 @@ video_packetizer_c::flush_frames(char next_frame,
queued_frames.clear();
}
if (flush_all) {
add_packet(bref_frame.data, bref_frame.size, bref_frame.duration,
false, bref_frame.bref, bref_frame.fref, -1, cp_no);
memory_c mem(bref_frame.data, bref_frame.size, false);
add_packet(mem, bref_frame.duration, false, bref_frame.bref,
bref_frame.fref);
bref_frame.type = '?';
}
return;
@ -347,15 +344,15 @@ video_packetizer_c::flush_frames(char next_frame,
frames_output++;
fref_frame.timecode = (int64_t)(fref_frame.timecode +
queued_frames.size() * 1000000000 / fps);
add_packet(fref_frame.data, fref_frame.size, fref_frame.timecode,
fref_frame.duration, false, fref_frame.bref, fref_frame.fref,
-1, cp_no);
memory_c fref_mem(fref_frame.data, fref_frame.size, false);
add_packet(fref_mem, fref_frame.timecode,
fref_frame.duration, false, fref_frame.bref, fref_frame.fref);
for (i = 0; i < queued_frames.size(); i++)
add_packet(queued_frames[i].data, queued_frames[i].size,
queued_frames[i].timecode, queued_frames[i].duration,
false, bref_frame.timecode, fref_frame.timecode, -1,
cp_no);
for (i = 0; i < queued_frames.size(); i++) {
memory_c mem(queued_frames[i].data, queued_frames[i].size, false);
add_packet(mem, queued_frames[i].timecode, queued_frames[i].duration,
false, bref_frame.timecode, fref_frame.timecode);
}
queued_frames.clear();
bref_frame = fref_frame;

2
src/output/p_video.h
View File

@ -54,7 +54,7 @@ public:
throw (error_c);
virtual ~video_packetizer_c();
virtual int process(unsigned char *buf, int size, int64_t old_timecode = -1,
virtual int process(memory_c &mem, int64_t old_timecode = -1,
int64_t duration = -1, int64_t bref = VFT_IFRAME,
int64_t fref = VFT_NOBFRAME);
virtual void set_headers();

18
src/output/p_vobsub.cpp
View File

@ -176,17 +176,17 @@ vobsub_packetizer_c::deliver_packet(unsigned char *buf,
}
if (duration != -2) {
timecode = (int64_t)((float)timecode * ti->async.linear);
add_packet(buf, size, timecode, duration, true);
}
safefree(buf);
memory_c mem(buf, size, true);
add_packet(mem, timecode, duration, true);
} else
safefree(buf);
return -1;
}
// Adopted from mplayer's vobsub.c
int
vobsub_packetizer_c::process(unsigned char *srcbuf,
int size,
vobsub_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t duration,
int64_t,
@ -207,7 +207,7 @@ vobsub_packetizer_c::process(unsigned char *srcbuf,
return EMOREDATA;
if (extract_from_mpeg) {
mm_mem_io_c in(srcbuf, size);
mm_mem_io_c in(mem.data, mem.size);
dst_buf = NULL;
dst_size = 0;
@ -337,7 +337,7 @@ vobsub_packetizer_c::process(unsigned char *srcbuf,
}
dst_size += packet_size;
spu_size += packet_size;
overhead += size - packet_size;
overhead += mem.size - packet_size;
idx = len;
}
@ -371,9 +371,9 @@ vobsub_packetizer_c::process(unsigned char *srcbuf,
return deliver();
}
spu_size += size;
spu_size += mem.size;
timecode = (int64_t)((float)timecode * ti->async.linear);
add_packet(srcbuf, size, timecode, duration, true);
add_packet(mem, timecode, duration, true);
return EMOREDATA;
}

2
src/output/p_vobsub.h
View File

@ -41,7 +41,7 @@ public:
throw (error_c);
virtual ~vobsub_packetizer_c();
virtual int process(unsigned char *srcbuf, int size,
virtual int process(memory_c &mem,
int64_t old_timecode = -1, int64_t duration = -1,
int64_t bref = -1, int64_t fref = -1);
virtual void set_headers();

14
src/output/p_vorbis.cpp
View File

@ -83,6 +83,8 @@ vorbis_packetizer_c::~vorbis_packetizer_c() {
for (i = 0; i < 3; i++)
if (headers[i].packet != NULL)
safefree(headers[i].packet);
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
void
@ -140,8 +142,7 @@ vorbis_packetizer_c::set_headers() {
* has to generate silence packets and put them into the Matroska file first.
*/
int
vorbis_packetizer_c::process(unsigned char *data,
int size,
vorbis_packetizer_c::process(memory_c &mem,
int64_t timecode,
int64_t,
int64_t,
@ -170,7 +171,8 @@ vorbis_packetizer_c::process(unsigned char *data,
samples += samples_here;
last_bs = this_bs;
samples_here = (this_bs + last_bs) / 4;
add_packet(zero, 2, samples * 1000 / vi.rate,
memory_c mem(zero, 2, false);
add_packet(mem, samples * 1000 / vi.rate,
samples_here * 1000000000 / vi.rate);
}
}
@ -189,8 +191,8 @@ vorbis_packetizer_c::process(unsigned char *data,
// Update the number of samples we have processed so that we can
// calculate the timecode on the next call.
op.packet = data;
op.bytes = size;
op.packet = mem.data;
op.bytes = mem.size;
this_bs = vorbis_packet_blocksize(&vi, &op);
samples_here = (this_bs + last_bs) / 4;
samples += samples_here;
@ -203,7 +205,7 @@ vorbis_packetizer_c::process(unsigned char *data,
}
mxverb(2, "Vorbis: samples_here: %lld\n", samples_here);
add_packet(data, size, (int64_t)timecode,
add_packet(mem, (int64_t)timecode,
(int64_t)(samples_here * 1000000000 * ti->async.linear /
vi.rate));

2
src/output/p_vorbis.h
View File

@ -47,7 +47,7 @@ public:
track_info_c *nti) throw (error_c);
virtual ~vorbis_packetizer_c();
virtual int process(unsigned char *data, int size, int64_t timecode = -1,
virtual int process(memory_c &mem, int64_t timecode = -1,
int64_t length = -1, int64_t bref = -1,
int64_t fref = -1);
virtual void set_headers();

38
src/pr_generic.cpp
View File

@ -54,7 +54,6 @@ generic_packetizer_c::generic_packetizer_c(generic_reader_c *nreader,
#endif
reader = nreader;
add_packetizer(this);
duplicate_data = true;
track_entry = NULL;
ti = new track_info_c(*nti);
@ -659,23 +658,21 @@ void generic_packetizer_c::set_headers() {
}
void
generic_packetizer_c::add_packet(unsigned char *data,
int length,
generic_packetizer_c::add_packet(memory_c &mem,
int64_t timecode,
int64_t duration,
bool duration_mandatory,
int64_t bref,
int64_t fref,
int ref_priority,
copy_packet_mode_t copy_this) {
int ref_priority) {
int length;
packet_t *pack;
if (data == NULL)
return;
if (timecode < 0) {
drop_packet(data, copy_this);
mem.release();
return;
}
// 'timecode < safety_last_timecode' may only occur for B frames. In this
// case we have the coding order, e.g. IPB1B2 and the timecodes
// I: 0, P: 120, B1: 40, B2: 80.
@ -688,16 +685,16 @@ generic_packetizer_c::add_packet(unsigned char *data,
pack = (packet_t *)safemalloc(sizeof(packet_t));
memset(pack, 0, sizeof(packet_t));
length = mem.size;
if (compressor != NULL) {
pack->data = compressor->compress(data, length);
if ((copy_this == cp_no) ||
((copy_this == cp_default) && !duplicate_data))
safefree(data);
} else if ((copy_this == cp_yes) ||
((copy_this == cp_default) && duplicate_data))
pack->data = (unsigned char *)safememdup(data, length);
else
pack->data = data;
pack->data = compressor->compress(mem.data, length);
mem.release();
} else if (!mem.is_free)
pack->data = (unsigned char *)safememdup(mem.data, mem.size);
else {
pack->data = mem.data;
mem.lock();
}
pack->length = length;
pack->timecode = timecode;
pack->bref = bref;
@ -713,13 +710,6 @@ generic_packetizer_c::add_packet(unsigned char *data,
enqueued_bytes += pack->length;
}
void generic_packetizer_c::drop_packet(unsigned char *data,
copy_packet_mode_t copy_this) {
if ((copy_this == cp_no) ||
((copy_this == cp_default) && !duplicate_data))
safefree(data);
}
packet_t *generic_packetizer_c::get_packet() {
packet_t *pack;

59
src/pr_generic.h
View File

@ -53,18 +53,53 @@ using namespace std;
#define CUES_ALL 2
#define CUES_SPARSE 3
class memory_c {
public:
unsigned char *data;
uint32_t size;
bool is_free;
public:
memory_c(unsigned char *ndata, uint32_t nsize, bool nis_free):
data(ndata), size(nsize), is_free(nis_free) {
if (data == NULL)
die("memory_c::memory_c: data = %p, size = %u\n", data, size);
}
memory_c(const memory_c &src) {
die("memory_c::memory_c(const memory_c &) called\n");
}
~memory_c() {
release();
}
int lock() {
is_free = false;
return 0;
}
memory_c *grab() {
if (size == 0)
die("memory_c::grab(): size == 0\n");
if (is_free) {
is_free = false;
return new memory_c(data, size, true);
}
return new memory_c((unsigned char *)safememdup(data, size), size, true);
}
int release() {
if (is_free) {
safefree(data);
data = NULL;
is_free = false;
}
return 0;
}
};
typedef struct {
int64_t displacement;
double linear;
int64_t id;
} audio_sync_t;
enum copy_packet_mode_t {
cp_default,
cp_yes,
cp_no
};
#define DEFAULT_TRACK_PRIOIRTY_NONE 0
#define DEFAULT_TRACK_PRIORITY_FROM_TYPE 10
#define DEFAULT_TRACK_PRIORITY_FROM_SOURCE 50
@ -218,7 +253,6 @@ class generic_packetizer_c {
protected:
deque<packet_t *> packet_queue;
generic_reader_c *reader;
bool duplicate_data;
track_info_c *ti;
int64_t initial_displacement;
@ -268,15 +302,10 @@ public:
track_entry = NULL;
}
virtual void duplicate_data_on_add(bool duplicate) {
duplicate_data = duplicate;
}
virtual void add_packet(unsigned char *data, int lenth, int64_t timecode,
virtual void add_packet(memory_c &mem, int64_t timecode,
int64_t duration, bool duration_mandatory = false,
int64_t bref = -1, int64_t fref = -1,
int ref_priority = -1,
copy_packet_mode_t copy_this = cp_default);
virtual void drop_packet(unsigned char *data, copy_packet_mode_t copy_this);
int ref_priority = -1);
virtual packet_t *get_packet();
virtual int packet_available() {
return packet_queue.size();
@ -298,7 +327,7 @@ public:
return free_refs;
}
virtual void set_headers();
virtual int process(unsigned char *data, int size,
virtual int process(memory_c &mem,
int64_t timecode = -1, int64_t length = -1,
int64_t bref = -1, int64_t fref = -1) = 0;