int quicktime_read_esds(quicktime_t *file, quicktime_esds_t *esds)
{
u_int8_t tag;
u_int32_t length;
esds->version = quicktime_read_char(file);
esds->flags = quicktime_read_int24(file);
/* get and verify ES_DescrTag */
tag = quicktime_read_char(file);
if (tag == 0x03) {
/* read length */
if (quicktime_read_mp4_descr_length(file) < 5 + 15) {
return 1;
}
/* skip 3 bytes */
quicktime_set_position(file, quicktime_position(file) + 3);
} else {
/* skip 2 bytes */
quicktime_set_position(file, quicktime_position(file) + 2);
}
/* get and verify DecoderConfigDescrTab */
if (quicktime_read_char(file) != 0x04) {
return 1;
}
/* read length */
if (quicktime_read_mp4_descr_length(file) < 15) {
return 1;
}
/* skip 13 bytes */
quicktime_set_position(file, quicktime_position(file) + 13);
/* get and verify DecSpecificInfoTag */
if (quicktime_read_char(file) != 0x05) {
return 1;
}
/* read length */
esds->decoderConfigLen = quicktime_read_mp4_descr_length(file);
free(esds->decoderConfig);
esds->decoderConfig = malloc(esds->decoderConfigLen);
if (esds->decoderConfig) {
quicktime_read_data(file, esds->decoderConfig, esds->decoderConfigLen);
} else {
esds->decoderConfigLen = 0;
}
/* will skip the remainder of the atom */
return 0;
}
void quicktime_read_stsd_audio(quicktime_t *file,
quicktime_stsd_table_t *table,
quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
table->version = quicktime_read_int16(file);
table->revision = quicktime_read_int16(file);
quicktime_read_data(file, table->vendor, 4);
table->channels = quicktime_read_int16(file);
table->sample_size = quicktime_read_int16(file);
table->compression_id = quicktime_read_int16(file);
table->packet_size = quicktime_read_int16(file);
table->sample_rate = quicktime_read_fixed32(file);
// Kluge for fixed32 limitation
if(table->sample_rate + 65536 == 96000 ||
table->sample_rate + 65536 == 88200) table->sample_rate += 65536;
// Version 1 fields
if(table->version > 0)
{
table->samples_per_packet = quicktime_read_int32(file);
table->bytes_per_packet = quicktime_read_int32(file);
table->bytes_per_frame = quicktime_read_int32(file);
table->bytes_per_sample = quicktime_read_int32(file);
// Skip another 20 bytes
if(table->version == 2)
{
quicktime_set_position(file, quicktime_position(file) + 0x14);
}
while(quicktime_position(file) < parent_atom->end)
{
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "wave"))
{
read_wave(file, table, &leaf_atom);
}
else
{
quicktime_atom_skip(file, &leaf_atom);
}
}
}
// FFMPEG says the esds sometimes contains a sample rate that overrides
// the sample table.
quicktime_esds_samplerate(table, &table->esds);
}
int quicktime_read_minf(quicktime_t *file, quicktime_minf_t *minf, quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
long pos = quicktime_position(file);
do
{
quicktime_atom_read_header(file, &leaf_atom);
/* mandatory */
if(quicktime_atom_is(&leaf_atom, "vmhd"))
{ minf->is_video = 1; quicktime_read_vmhd(file, &(minf->vmhd)); }
else
if(quicktime_atom_is(&leaf_atom, "smhd"))
{ minf->is_audio = 1; quicktime_read_smhd(file, &(minf->smhd)); }
else
if(quicktime_atom_is(&leaf_atom, "gmhd"))
{ minf->is_hint = 1; quicktime_read_gmhd(file, &(minf->gmhd), &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "hmhd"))
{ minf->is_hint = 1; quicktime_read_hmhd(file, &(minf->hmhd), &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "hdlr"))
{
quicktime_read_hdlr(file, &(minf->hdlr));
/* Main Actor doesn't write component name */
quicktime_atom_skip(file, &leaf_atom);
}
else
if(quicktime_atom_is(&leaf_atom, "dinf"))
{ quicktime_read_dinf(file, &(minf->dinf), &leaf_atom); }
else
quicktime_atom_skip(file, &leaf_atom);
}while(quicktime_position(file) < parent_atom->end);
quicktime_set_position(file, pos);
do {
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "stbl")) {
quicktime_read_stbl(file, minf, &(minf->stbl), &leaf_atom);
} else {
quicktime_atom_skip(file, &leaf_atom);
}
} while(quicktime_position(file) < parent_atom->end);
return 0;
}
void quicktime_atom_write_footer(quicktime_t *file, quicktime_atom_t *atom)
{
atom->end = quicktime_position(file);
if(file->use_avi)
{
quicktime_set_position(file, atom->start - 4);
quicktime_write_int32_le(file, atom->end - atom->start);
atom->size = atom->end - atom->start;
}
else
{
// We should calculate atom->size here also... it is used in trak.c FIXME
// I don't know internals of the quicktime to know what is proper calculation - with or wirhout header?
if(atom->use_64)
{
quicktime_set_position(file, atom->start + 8);
//printf("quicktime_atom_write_footer %llx %llx %llx %llx\n", file->total_length, file->file_position, atom->start, atom->end);
quicktime_write_int64(file, atom->end - atom->start);
}
else
{
quicktime_set_position(file, atom->start);
quicktime_write_int32(file, atom->end - atom->start);
}
}
quicktime_set_position(file, atom->end);
}
int quicktime_update_positions(quicktime_t *file)
{
/* Get the sample position from the file offset */
/* for routines that change the positions of all tracks, like */
/* seek_end and seek_start but not for routines that reposition one track, like */
/* set_audio_position. */
int64_t mdat_offset = quicktime_position(file) - file->mdat.atom.start;
int64_t sample, chunk, chunk_offset;
int i;
if(file->total_atracks)
{
sample = quicktime_offset_to_sample(file->atracks[0].track, mdat_offset);
chunk = quicktime_offset_to_chunk(&chunk_offset, file->atracks[0].track, mdat_offset);
for(i = 0; i < file->total_atracks; i++)
{
file->atracks[i].current_position = sample;
file->atracks[i].current_chunk = chunk;
}
}
if(file->total_vtracks)
{
sample = quicktime_offset_to_sample(file->vtracks[0].track, mdat_offset);
chunk = quicktime_offset_to_chunk(&chunk_offset, file->vtracks[0].track, mdat_offset);
for(i = 0; i < file->total_vtracks; i++)
{
file->vtracks[i].current_position = sample;
file->vtracks[i].current_chunk = chunk;
}
}
return 0;
}
int quicktime_write_audio(quicktime_t *file, char *audio_buffer, long samples, int track)
{
long offset;
int result;
long bytes;
/* Defeat 32 bit file size limit. */
if(quicktime_test_position(file)) return 1;
/* write chunk for 1 track */
bytes = samples * quicktime_audio_bits(file, track) / 8 * file->atracks[track].channels;
offset = quicktime_position(file);
result = quicktime_write_data(file, audio_buffer, bytes);
if(result) result = 0; else result = 1; /* defeat fwrite's return */
quicktime_update_tables(file,
file->atracks[track].track,
offset,
file->atracks[track].current_chunk,
file->atracks[track].current_position,
samples,
0,
0,
0,
0);
file->atracks[track].current_position += samples;
file->atracks[track].current_chunk++;
return result;
}
int quicktime_write_video_frame(quicktime_t *file,
unsigned char *video_buffer,
long bytes,
int track,
u_char isKeyFrame,
long duration,
long renderingOffset)
{
long offset = quicktime_position(file);
int result = 0;
/* Defeat 32 bit file size limit. */
if(quicktime_test_position(file)) return 1;
result = quicktime_write_data(file, video_buffer, bytes);
if(result) result = 0; else result = 1;
quicktime_update_tables(file,
file->vtracks[track].track,
offset,
file->vtracks[track].current_chunk,
file->vtracks[track].current_position,
1,
bytes,
duration,
isKeyFrame,
renderingOffset);
file->vtracks[track].current_position += 1;
file->vtracks[track].current_chunk++;
return result;
}
void quicktime_read_hdrl(quicktime_t *file,
quicktime_hdrl_t *hdrl,
quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
char data[4];
int current_track = 0;
//printf("quicktime_read_hdrl 1\n");
do
{
quicktime_atom_read_header(file, &leaf_atom);
/* Got LIST */
if(quicktime_atom_is(&leaf_atom, "LIST"))
{
data[0] = data[1] = data[2] = data[3] = 0;
quicktime_read_data(file, data, 4);
/* Got strl */
if(quicktime_match_32(data, "strl"))
{
quicktime_strl_t *strl =
hdrl->strl[current_track++] =
quicktime_new_strl();
quicktime_read_strl(file, strl, &leaf_atom);
}
}
quicktime_atom_skip(file, &leaf_atom);
}while(quicktime_position(file) < parent_atom->end);
quicktime_atom_skip(file, &leaf_atom);
}
int quicktime_read_mdia(quicktime_t *file, quicktime_mdia_t *mdia, quicktime_atom_t *trak_atom)
{
quicktime_atom_t leaf_atom;
do
{
quicktime_atom_read_header(file, &leaf_atom);
/* mandatory */
if(quicktime_atom_is(&leaf_atom, "mdhd"))
{ quicktime_read_mdhd(file, &(mdia->mdhd)); }
else
if(quicktime_atom_is(&leaf_atom, "hdlr"))
{
quicktime_read_hdlr(file, &(mdia->hdlr));
/* Main Actor doesn't write component name */
quicktime_atom_skip(file, &leaf_atom);
/*printf("quicktime_read_mdia %ld\n", quicktime_position(file)); */
}
else
if(quicktime_atom_is(&leaf_atom, "minf"))
{ quicktime_read_minf(file, &(mdia->minf), &leaf_atom); }
else
quicktime_atom_skip(file, &leaf_atom);
}while(quicktime_position(file) < trak_atom->end);
return 0;
}
int quicktime_write_audio_frame(quicktime_t *file, unsigned char *audio_buffer, long bytes, int track)
{
long offset = quicktime_position(file);
int result = 0;
/* Defeat 32 bit file size limit. */
if(quicktime_test_position(file)) return 1;
result = quicktime_write_data(file, audio_buffer, bytes);
if(result) result = 0; else result = 1;
quicktime_update_tables(file,
file->atracks[track].track,
offset,
file->atracks[track].current_chunk,
file->atracks[track].current_position,
1,
bytes,
0,
0,
0);
file->atracks[track].current_position += 1;
file->atracks[track].current_chunk++;
return result;
}
static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
{
int64_t offset = quicktime_position(file);
quicktime_video_map_t *vtrack = &(file->vtracks[track]);
quicktime_v308_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
quicktime_trak_t *trak = vtrack->track;
int width = vtrack->track->tkhd.track_width;
int height = vtrack->track->tkhd.track_height;
int bytes = width * height * 3;
int result = 0;
unsigned char **output_rows;
int i;
quicktime_atom_t chunk_atom;
if(!codec->work_buffer)
codec->work_buffer = malloc(vtrack->track->tkhd.track_width *
vtrack->track->tkhd.track_height *
3);
output_rows = malloc(sizeof(unsigned char*) * height);
for(i = 0; i < height; i++)
output_rows[i] = codec->work_buffer + i * width * 3;
cmodel_transfer(output_rows,
row_pointers,
0,
0,
0,
row_pointers[0],
row_pointers[1],
row_pointers[2],
0,
0,
width,
height,
0,
0,
width,
height,
file->color_model,
BC_VYU888,
0,
width,
width);
quicktime_write_chunk_header(file, trak, &chunk_atom);
result = !quicktime_write_data(file, codec->work_buffer, bytes);
quicktime_write_chunk_footer(file,
trak,
vtrack->current_chunk,
&chunk_atom,
1);
vtrack->current_chunk++;
free(output_rows);
return result;
}
int quicktime_read_hint(quicktime_t *file, quicktime_hint_t *hint, quicktime_atom_t *parent_atom)
{
quicktime_trak_t* refTrak = NULL;
int i;
while (quicktime_position(file) < parent_atom->end) {
hint->trackIds[hint->numTracks] = quicktime_read_int32(file);
hint->traks[hint->numTracks] = NULL;
hint->numTracks++;
}
}
int quicktime_atom_write_header64(quicktime_t *file, quicktime_atom_t *atom, char *text)
{
int result = 0;
atom->start = quicktime_position(file);
result = !quicktime_write_int32(file, 1);
if(!result) result = !quicktime_write_char32(file, text);
if(!result) result = !quicktime_write_int64(file, 0);
atom->use_64 = 1;
return result;
}
void quicktime_read_dinf(quicktime_t *file, quicktime_dinf_t *dinf, quicktime_atom_t *dinf_atom)
{
quicktime_atom_t leaf_atom;
do
{
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "dref"))
{ quicktime_read_dref(file, &(dinf->dref)); }
else
quicktime_atom_skip(file, &leaf_atom);
}while(quicktime_position(file) < dinf_atom->end);
}
static int quicktime_write_media_hint(quicktime_t* file,
u_char* hintBuffer,
long hintBufferSize,
quicktime_trak_t* hintTrak,
long* pSampleNumber,
long hintSampleDuration,
u_char isSyncSample)
{
long offset = quicktime_position(file);
quicktime_hint_info_t hintInfo;
int result = 0;
/* handle 32 bit file size limit */
if (quicktime_test_position(file)) {
return 1;
}
/* get info about this hint */
quicktime_get_hint_info(hintBuffer, hintBufferSize, &hintInfo);
/* update overall info */
hintTrak->hint_udta.hinf.trpy.numBytes += hintInfo.trpy;
hintTrak->hint_udta.hinf.nump.numPackets += hintInfo.nump;
hintTrak->hint_udta.hinf.tpyl.numBytes += hintInfo.tpyl;
hintTrak->hint_udta.hinf.dmed.numBytes += hintInfo.dmed;
hintTrak->hint_udta.hinf.drep.numBytes += hintInfo.drep;
hintTrak->hint_udta.hinf.dimm.numBytes += hintInfo.dimm;
hintTrak->hint_udta.hinf.tmin.milliSecs =
MAX(hintInfo.tmin, hintTrak->hint_udta.hinf.tmin.milliSecs);
hintTrak->hint_udta.hinf.tmax.milliSecs =
MAX(hintInfo.tmax, hintTrak->hint_udta.hinf.tmax.milliSecs);
hintTrak->hint_udta.hinf.pmax.numBytes =
MAX(hintInfo.pmax, hintTrak->hint_udta.hinf.pmax.numBytes);
hintTrak->mdia.minf.hmhd.maxPDUsize =
hintTrak->hint_udta.hinf.pmax.numBytes;
hintTrak->mdia.minf.hmhd.avgPDUsize =
hintTrak->hint_udta.hinf.trpy.numBytes
/ hintTrak->hint_udta.hinf.nump.numPackets;
/* write the hint data */
result = quicktime_write_data(file, hintBuffer, hintBufferSize);
result = (result ? 0 : 1);
quicktime_update_tables(file, hintTrak, offset, *pSampleNumber + 1,
*pSampleNumber, 1, hintBufferSize, hintSampleDuration, isSyncSample, 0);
(*pSampleNumber)++;
return result;
}
int quicktime_read_gmhd(quicktime_t *file, quicktime_gmhd_t *gmhd, quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
do {
quicktime_atom_read_header(file, &leaf_atom);
if (quicktime_atom_is(&leaf_atom, "gmin")) {
quicktime_read_gmin(file, &(gmhd->gmin));
} else {
quicktime_atom_skip(file, &leaf_atom);
}
} while (quicktime_position(file) < parent_atom->end);
}
int quicktime_read_tref(quicktime_t *file, quicktime_tref_t *tref, quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
do {
quicktime_atom_read_header(file, &leaf_atom);
if (quicktime_atom_is(&leaf_atom, "hint")) {
quicktime_read_hint(file, &(tref->hint), &leaf_atom);
} else {
quicktime_atom_skip(file, &leaf_atom);
}
} while (quicktime_position(file) < parent_atom->end);
}
int quicktime_close(quicktime_t *file)
{
int result = 0;
if(file->wr)
{
quicktime_codecs_flush(file);
// Reenable buffer for quick header writing.
quicktime_set_presave(file, 1);
if(file->use_avi)
{
quicktime_atom_t junk_atom;
int i;
// Finalize last header
quicktime_finalize_riff(file, file->riff[file->total_riffs - 1]);
int64_t position = quicktime_position(file);
// Finalize the odml header
quicktime_finalize_odml(file, &file->riff[0]->hdrl);
// Finalize super indexes
quicktime_finalize_indx(file);
// Pad ending
quicktime_set_position(file, position);
quicktime_atom_write_header(file, &junk_atom, "JUNK");
for(i = 0; i < 0x406; i++)
quicktime_write_int32_le(file, 0);
quicktime_atom_write_footer(file, &junk_atom);
}
else
{
// Atoms are only written here
if(file->stream)
{
quicktime_write_moov(file, &(file->moov));
quicktime_atom_write_footer(file, &file->mdat.atom);
}
}
}
quicktime_file_close(file);
quicktime_delete(file);
free(file);
return result;
}
int quicktime_read_moov(quicktime_t *file, quicktime_moov_t *moov, quicktime_atom_t *parent_atom)
{
/* mandatory mvhd */
quicktime_atom_t leaf_atom;
do
{
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "mvhd"))
{
quicktime_read_mvhd(file, &(moov->mvhd));
}
else
if(quicktime_atom_is(&leaf_atom, "iods"))
{
quicktime_read_iods(file, &(moov->iods));
quicktime_atom_skip(file, &leaf_atom);
}
else
if(quicktime_atom_is(&leaf_atom, "clip"))
{
quicktime_atom_skip(file, &leaf_atom);
}
else
if(quicktime_atom_is(&leaf_atom, "trak"))
{
quicktime_trak_t *trak = quicktime_add_trak(moov);
quicktime_read_trak(file, trak, &leaf_atom);
}
else
if(quicktime_atom_is(&leaf_atom, "udta"))
{
quicktime_read_udta(file, &(moov->udta), &leaf_atom);
quicktime_atom_skip(file, &leaf_atom);
}
else
if(quicktime_atom_is(&leaf_atom, "ctab"))
{
quicktime_read_ctab(file, &(moov->ctab));
}
else
{
quicktime_atom_skip(file, &leaf_atom);
}
}while(quicktime_position(file) < parent_atom->end);
return 0;
}
int quicktime_atom_write_header(quicktime_t *file,
quicktime_atom_t *atom,
char *text)
{
int result = 0;
if(file->use_avi)
{
reset(atom);
atom->start = quicktime_position(file) + 8;
result = !quicktime_write_char32(file, text);
if(!result) result = !quicktime_write_int32_le(file, 0);
atom->use_64 = 0;
}
else
{
atom->start = quicktime_position(file);
result = !quicktime_write_int32(file, 0);
if(!result) result = !quicktime_write_char32(file, text);
atom->use_64 = 0;
}
return result;
}
static void read_wave(quicktime_t *file,
quicktime_stsd_table_t *table,
quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
while(quicktime_position(file) < parent_atom->end)
{
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "esds"))
{
quicktime_read_esds(file, &leaf_atom, &table->esds);
}
else
quicktime_atom_skip(file, &leaf_atom);
}
}
int quicktime_read_hnti(quicktime_t *file, quicktime_hnti_t *hnti, quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
do {
quicktime_atom_read_header(file, &leaf_atom);
if (quicktime_atom_is(&leaf_atom, "rtp ")) {
quicktime_read_rtp(file, &(hnti->rtp), &leaf_atom);
} else {
quicktime_atom_skip(file, &leaf_atom);
}
} while (quicktime_position(file) < parent_atom->end);
return 0;
}
int quicktime_check_sig(char *path)
{
quicktime_t file;
quicktime_atom_t leaf_atom;
int result = 0, result1 = 0, result2 = 0;
char avi_test[12];
quicktime_init(&file);
result = quicktime_file_open(&file, path, 1, 0);
if(!result)
{
// Check for Microsoft AVI
quicktime_read_data(&file, avi_test, 12);
quicktime_set_position(&file, 0);
if(quicktime_match_32(avi_test, "RIFF") &&
quicktime_match_32(avi_test + 8, "AVI "))
{
result2 = 1;
}
else
{
do
{
result1 = quicktime_atom_read_header(&file, &leaf_atom);
if(!result1)
{
/* just want the "moov" atom */
if(quicktime_atom_is(&leaf_atom, "moov"))
{
result2 = 1;
}
else
quicktime_atom_skip(&file, &leaf_atom);
}
}while(!result1 && !result2 && quicktime_position(&file) < file.total_length);
}
}
//printf(__FUNCTION__ " 2 %d\n", result2);
quicktime_file_close(&file);
quicktime_delete(&file);
return result2;
}
void quicktime_init_odml(quicktime_t *file, quicktime_hdrl_t *hdrl)
{
quicktime_atom_t list_atom, dmlh_atom;
// LIST 'odml'
quicktime_atom_write_header(file, &list_atom, "LIST");
quicktime_write_char32(file, "odml");
// 'dmlh'
quicktime_atom_write_header(file, &dmlh_atom, "dmlh");
// Placeholder for total frames in all RIFF objects
hdrl->total_frames_offset = quicktime_position(file);
quicktime_write_int32_le(file, 0);
quicktime_atom_write_footer(file, &dmlh_atom);
quicktime_atom_write_footer(file, &list_atom);
}
void quicktime_read_indx(quicktime_t *file,
quicktime_strl_t *strl,
quicktime_atom_t *parent_atom)
{
quicktime_indx_t *indx = &strl->indx;
quicktime_indxtable_t *indx_table;
quicktime_ix_t *ix;
int i;
int64_t offset;
indx->longs_per_entry = quicktime_read_int16_le(file);
indx->index_subtype = quicktime_read_char(file);
indx->index_type = quicktime_read_char(file);
indx->table_size = quicktime_read_int32_le(file);
quicktime_read_char32(file, indx->chunk_id);
quicktime_read_int32_le(file);
quicktime_read_int32_le(file);
quicktime_read_int32_le(file);
// file->is_odml = 1;
//printf("quicktime_read_indx 1\n");
/* Read indx entries */
indx->table = calloc(indx->table_size, sizeof(quicktime_indxtable_t));
for(i = 0; i < indx->table_size; i++)
{
indx_table = &indx->table[i];
indx_table->index_offset = quicktime_read_int64_le(file);
indx_table->index_size = quicktime_read_int32_le(file);
indx_table->duration = quicktime_read_int32_le(file);
offset = quicktime_position(file);
indx_table->ix = calloc(indx->table_size, sizeof(quicktime_ix_t*));
/* Now read the partial index */
ix = indx_table->ix = calloc(1, sizeof(quicktime_ix_t));
quicktime_set_position(file, indx_table->index_offset);
quicktime_read_ix(file, ix);
quicktime_set_position(file, offset);
}
//printf("quicktime_read_indx 100\n");
}
int quicktime_write_frame_end(quicktime_t *file, int track)
{
long bytes;
file->file_position = ftell(file->stream);
bytes = quicktime_position(file) - file->offset;
quicktime_update_tables(file,
file->vtracks[track].track,
file->offset,
file->vtracks[track].current_chunk,
file->vtracks[track].current_position,
1,
bytes,
0,
0,
0);
file->vtracks[track].current_position += 1;
file->vtracks[track].current_chunk++;
return 0;
}
int quicktime_write_audio_end(quicktime_t *file, int track, long samples)
{
long bytes;
file->file_position = ftell(file->stream);
bytes = quicktime_position(file) - file->offset;
quicktime_update_tables(file,
file->atracks[track].track,
file->offset,
file->atracks[track].current_chunk,
file->atracks[track].current_position,
samples,
bytes,
0,
0,
0);
file->atracks[track].current_position += samples;
file->atracks[track].current_chunk++;
return 0;
}
int quicktime_read_trak(quicktime_t *file, quicktime_trak_t *trak, quicktime_atom_t *trak_atom)
{
quicktime_atom_t leaf_atom;
do
{
quicktime_atom_read_header(file, &leaf_atom);
/* mandatory */
if(quicktime_atom_is(&leaf_atom, "tkhd"))
{ quicktime_read_tkhd(file, &(trak->tkhd)); }
else
if(quicktime_atom_is(&leaf_atom, "mdia"))
{ quicktime_read_mdia(file, &(trak->mdia), &leaf_atom); }
else
/* optional */
if(quicktime_atom_is(&leaf_atom, "clip"))
{ quicktime_atom_skip(file, &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "matt"))
{ quicktime_atom_skip(file, &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "edts"))
{ quicktime_read_edts(file, &(trak->edts), &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "load"))
{ quicktime_atom_skip(file, &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "tref"))
{ quicktime_read_tref(file, &(trak->tref), &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "imap"))
{ quicktime_atom_skip(file, &leaf_atom); }
else
if(quicktime_atom_is(&leaf_atom, "udta"))
{ quicktime_read_hint_udta(file, &(trak->hint_udta), &leaf_atom); }
else
quicktime_atom_skip(file, &leaf_atom);
}while(quicktime_position(file) < trak_atom->end);
return 0;
}
static void read_wave(quicktime_t *file,
quicktime_stsd_table_t *table,
quicktime_atom_t *parent_atom)
{
quicktime_atom_t leaf_atom;
//printf("read_wave 1 start=0x%llx\n", quicktime_position(file));
while(quicktime_position(file) < parent_atom->end)
{
quicktime_atom_read_header(file, &leaf_atom);
if(quicktime_atom_is(&leaf_atom, "esds"))
{
quicktime_read_esds(file, &leaf_atom, &table->esds);
}
else if(quicktime_atom_is(&leaf_atom, "frma"))
{
// Extra data for QDM2
quicktime_read_frma(file, parent_atom, &leaf_atom, &table->frma);
}
else
quicktime_atom_skip(file, &leaf_atom);
}
}
int quicktime_write_frame(quicktime_t *file,
unsigned char *video_buffer,
int64_t bytes,
int track)
{
int64_t offset = quicktime_position(file);
int result = 0;
quicktime_atom_t chunk_atom;
quicktime_video_map_t *vtrack = &file->vtracks[track];
quicktime_trak_t *trak = vtrack->track;
quicktime_write_chunk_header(file, trak, &chunk_atom);
result = !quicktime_write_data(file, video_buffer, bytes);
quicktime_write_chunk_footer(file,
trak,
vtrack->current_chunk,
&chunk_atom,
1);
file->vtracks[track].current_position++;
file->vtracks[track].current_chunk++;
return result;
}
