diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/demuxers/demux_qt.c | 1518 |
1 files changed, 762 insertions, 756 deletions
diff --git a/src/demuxers/demux_qt.c b/src/demuxers/demux_qt.c index 53ab84190..afed8f15c 100644 --- a/src/demuxers/demux_qt.c +++ b/src/demuxers/demux_qt.c @@ -30,7 +30,7 @@ * build_frame_table * free_qt_info * - * $Id: demux_qt.c,v 1.143 2003/02/03 02:10:53 miguelfreitas Exp $ + * $Id: demux_qt.c,v 1.144 2003/02/16 05:10:23 tmmm Exp $ * */ @@ -113,6 +113,8 @@ typedef unsigned int qt_atom; #define ATOM_PREAMBLE_SIZE 8 #define PALETTE_COUNT 256 +#define MAX_PTS_DIFF 100000 + /* these are things that can go wrong */ typedef enum { QT_OK, @@ -135,12 +137,10 @@ typedef enum { } media_type; typedef struct { - media_type type; int64_t offset; unsigned int size; int64_t pts; int keyframe; - unsigned int official_byte_count; } qt_frame; typedef struct { @@ -165,25 +165,57 @@ typedef struct { union { struct { - unsigned int codec_format; + unsigned int codec_fourcc; + unsigned int codec_buftype; unsigned int width; unsigned int height; int palette_count; palette_entry_t palette[PALETTE_COUNT]; int depth; + int edit_list_compensation; /* special trick for edit lists */ } video; struct { - unsigned int codec_format; + unsigned int codec_fourcc; + unsigned int codec_buftype; unsigned int sample_rate; unsigned int channels; unsigned int bits; unsigned int vbr; unsigned int wave_present; xine_waveformatex wave; + + /* special audio parameters */ + unsigned int samples_per_packet; + unsigned int bytes_per_packet; + unsigned int bytes_per_frame; + unsigned int bytes_per_sample; + unsigned int samples_per_frame; } audio; - } media_description; + } properties; + + /* internal frame table corresponding to this trak */ + qt_frame *frames; + unsigned int frame_count; + unsigned int current_frame; + + /* trak timescale */ + unsigned int timescale; + + /* flags that indicate how a trak is supposed to be used */ + unsigned int flags; + + /* decoder data pass information to the AAC decoder */ + void *decoder_config; + int decoder_config_len; + + /* verbatim copy of the stsd atom */ + int stsd_size; + void *stsd; + + /****************************************/ + /* temporary tables for loading a chunk */ /* edit list table */ unsigned int edit_list_count; @@ -210,32 +242,7 @@ typedef struct { unsigned int time_to_sample_count; time_to_sample_table_t *time_to_sample_table; - /* temporary frame table corresponding to this sample table */ - qt_frame *frames; - unsigned int frame_count; - - /* trak timescale */ - unsigned int timescale; - - /* flags that indicate how a trak is supposed to be used */ - unsigned int flags; - - /* decoder data pass information to the AAC decoder */ - void *decoder_config; - int decoder_config_len; - - /* special audio parameters */ - unsigned int samples_per_packet; - unsigned int bytes_per_packet; - unsigned int bytes_per_frame; - unsigned int bytes_per_sample; - unsigned int samples_per_frame; - - /* verbatim copy of the stsd atom */ - int stsd_size; - void *stsd; - -} qt_sample_table; +} qt_trak; typedef struct { FILE *qt_file; @@ -247,41 +254,18 @@ typedef struct { unsigned int duration; int64_t moov_first_offset; - int64_t moov_last_offset; - - qt_atom audio_codec; - unsigned int audio_type; - unsigned int audio_sample_rate; - unsigned int audio_channels; - unsigned int audio_bits; - unsigned int audio_vbr; /* flag to indicate if audio is VBR */ - void *audio_decoder_config; - int audio_decoder_config_len; - int wave_present; - xine_waveformatex wave; - int audio_stsd_size; - void *audio_stsd; - - qt_atom video_codec; - unsigned int video_type; - unsigned int video_width; - unsigned int video_height; - unsigned int video_depth; - void *video_decoder_config; - int video_decoder_config_len; - int video_stsd_size; - void *video_stsd; + int trak_count; + qt_trak *traks; - qt_frame *frames; - unsigned int frame_count; - - int palette_count; - palette_entry_t palette[PALETTE_COUNT]; + /* the trak numbers that won their respective frame count competitions */ + int video_trak; + int audio_trak; + int seek_flag; /* this is set to indicate that a seek has just occurred */ - char *copyright; - char *description; - char *comment; + char *copyright; + char *description; + char *comment; qt_error last_error; } qt_info; @@ -301,10 +285,6 @@ typedef struct { int status; - /* when this flag is set, demuxer only dispatches audio samples until it - * encounters a video keyframe, then it starts sending every frame again */ - int waiting_for_keyframe; - qt_info *qt; xine_bmiheader bih; unsigned int current_frame; @@ -395,7 +375,7 @@ static void hexdump (char *buf, int length) { for (i = 0; i < length; i++) { unsigned char c = buf[i]; - if ((c >= 32) && (c <= 128)) + if ((c >= 32) && (c < 128)) printf ("%c", c); else printf ("."); @@ -418,7 +398,7 @@ static void hexdump (char *buf, int length) { printf ("\n"); } -void dump_moov_atom(unsigned char *moov_atom, int moov_atom_size) { +static inline void dump_moov_atom(unsigned char *moov_atom, int moov_atom_size) { #if DEBUG_DUMP_MOOV FILE *f; @@ -540,7 +520,6 @@ qt_info *create_qt_info(void) { if (!info) return NULL; - info->frames = NULL; info->qt_file = NULL; info->compressed_header = 0; @@ -549,29 +528,11 @@ qt_info *create_qt_info(void) { info->timescale = 0; info->duration = 0; - info->audio_codec = 0; - info->audio_type = 0; - info->audio_sample_rate = 0; - info->audio_channels = 0; - info->audio_bits = 0; - info->audio_vbr = 0; - info->audio_decoder_config = NULL; - info->audio_decoder_config_len = 0; - info->audio_stsd = NULL; - - info->video_codec = 0; - info->video_type = 0; - info->video_width = 0; - info->video_height = 0; - info->video_depth = 0; - info->video_decoder_config = NULL; - info->video_decoder_config_len = 0; - info->video_stsd = NULL; - - info->frames = NULL; - info->frame_count = 0; - - info->palette_count = 0; + info->trak_count = 0; + info->traks = NULL; + + info->video_trak = -1; + info->audio_trak = -1; info->copyright = NULL; info->description = NULL; @@ -586,14 +547,8 @@ qt_info *create_qt_info(void) { void free_qt_info(qt_info *info) { if(info) { - if(info->frames) - free(info->frames); - if(info->audio_decoder_config) - free(info->audio_decoder_config); - if(info->video_decoder_config) - free(info->video_decoder_config); - free(info->audio_stsd); - free(info->video_stsd); + if(info->traks) + free(info->traks); free(info->copyright); free(info->description); free(info->comment); @@ -658,9 +613,9 @@ static int mp4_read_descr_len(unsigned char *s, uint32_t *length) { /* * This function traverses through a trak atom searching for the sample - * table atoms, which it loads into an internal sample table structure. + * table atoms, which it loads into an internal trak structure. */ -static qt_error parse_trak_atom (qt_sample_table *sample_table, +static qt_error parse_trak_atom (qt_trak *trak, unsigned char *trak_atom) { int i, j; @@ -681,52 +636,44 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, unsigned char *color_table; /* initialize sample table structure */ - sample_table->edit_list_count = 0; - sample_table->edit_list_table = NULL; - sample_table->chunk_offset_count = 0; - sample_table->chunk_offset_table = NULL; - sample_table->sample_size = 0; - sample_table->sample_size_count = 0; - sample_table->sample_size_table = NULL; - sample_table->sync_sample_table = 0; - sample_table->sync_sample_table = NULL; - sample_table->sample_to_chunk_count = 0; - sample_table->sample_to_chunk_table = NULL; - sample_table->time_to_sample_count = 0; - sample_table->time_to_sample_table = NULL; - sample_table->frames = NULL; - sample_table->decoder_config = NULL; - sample_table->decoder_config_len = 0; - sample_table->stsd = NULL; - memset(&sample_table->media_description, 0, - sizeof(sample_table->media_description)); - - /* special audio parameters */ - sample_table->samples_per_packet = 0; - sample_table->bytes_per_packet = 0; - sample_table->bytes_per_frame = 0; - sample_table->bytes_per_sample = 0; - sample_table->samples_per_frame = 0; + trak->edit_list_count = 0; + trak->edit_list_table = NULL; + trak->chunk_offset_count = 0; + trak->chunk_offset_table = NULL; + trak->sample_size = 0; + trak->sample_size_count = 0; + trak->sample_size_table = NULL; + trak->sync_sample_table = 0; + trak->sync_sample_table = NULL; + trak->sample_to_chunk_count = 0; + trak->sample_to_chunk_table = NULL; + trak->time_to_sample_count = 0; + trak->time_to_sample_table = NULL; + trak->frames = NULL; + trak->decoder_config = NULL; + trak->decoder_config_len = 0; + trak->stsd = NULL; + memset(&trak->properties, 0, sizeof(trak->properties)); /* default type */ - sample_table->type = MEDIA_OTHER; + trak->type = MEDIA_OTHER; /* search for media type atoms */ for (i = ATOM_PREAMBLE_SIZE; i < trak_atom_size - 4; i++) { current_atom = BE_32(&trak_atom[i]); if (current_atom == VMHD_ATOM) { - sample_table->type = MEDIA_VIDEO; + trak->type = MEDIA_VIDEO; break; } else if (current_atom == SMHD_ATOM) { - sample_table->type = MEDIA_AUDIO; + trak->type = MEDIA_AUDIO; break; } } debug_atom_load(" qt: parsing %s trak atom\n", - (sample_table->type == MEDIA_VIDEO) ? "video" : - (sample_table->type == MEDIA_AUDIO) ? "audio" : "other"); + (trak->type == MEDIA_VIDEO) ? "video" : + (trak->type == MEDIA_AUDIO) ? "audio" : "other"); /* search for the useful atoms */ for (i = ATOM_PREAMBLE_SIZE; i < trak_atom_size - 4; i++) { @@ -734,55 +681,57 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, current_atom = BE_32(&trak_atom[i]); if (current_atom == TKHD_ATOM) { - sample_table->flags = BE_16(&trak_atom[i + 6]); + trak->flags = BE_16(&trak_atom[i + 6]); - if (sample_table->type == MEDIA_VIDEO) { + if (trak->type == MEDIA_VIDEO) { /* fetch display parameters */ - if( !sample_table->media_description.video.width || - !sample_table->media_description.video.height ) { + if( !trak->properties.video.width || + !trak->properties.video.height ) { - sample_table->media_description.video.width = + trak->properties.video.width = BE_16(&trak_atom[i + 0x50]); - sample_table->media_description.video.height = + trak->properties.video.height = BE_16(&trak_atom[i + 0x54]); } } } else if (current_atom == ELST_ATOM) { /* there should only be one edit list table */ - if (sample_table->edit_list_table) { + if (trak->edit_list_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->edit_list_count = BE_32(&trak_atom[i + 8]); + trak->edit_list_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt elst atom (edit list atom): %d entries\n", - sample_table->edit_list_count); + trak->edit_list_count); - sample_table->edit_list_table = (edit_list_table_t *)malloc( - sample_table->edit_list_count * sizeof(edit_list_table_t)); - if (!sample_table->edit_list_table) { + trak->edit_list_table = (edit_list_table_t *)malloc( + trak->edit_list_count * sizeof(edit_list_table_t)); + if (!trak->edit_list_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the edit list table */ - for (j = 0; j < sample_table->edit_list_count; j++) { - sample_table->edit_list_table[j].track_duration = + for (j = 0; j < trak->edit_list_count; j++) { + trak->edit_list_table[j].track_duration = BE_32(&trak_atom[i + 12 + j * 12 + 0]); - sample_table->edit_list_table[j].media_time = + trak->edit_list_table[j].media_time = BE_32(&trak_atom[i + 12 + j * 12 + 4]); debug_atom_load(" %d: track duration = %d, media time = %d\n", j, - sample_table->edit_list_table[j].track_duration, - sample_table->edit_list_table[j].media_time); + trak->edit_list_table[j].track_duration, + trak->edit_list_table[j].media_time); } } else if (current_atom == MDHD_ATOM) - sample_table->timescale = BE_32(&trak_atom[i + 0x10]); + trak->timescale = BE_32(&trak_atom[i + 0x10]); else if (current_atom == STSD_ATOM) { + int hack_adjust; + debug_atom_load ("demux_qt: stsd atom\n"); #if DEBUG_ATOM_LOAD hexdump (&trak_atom[i], current_atom_size); @@ -790,33 +739,57 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, /* copy whole stsd atom so it can later be sent to the decoder */ - sample_table->stsd_size = current_atom_size; - sample_table->stsd = xine_xmalloc (current_atom_size); - memcpy (sample_table->stsd, &trak_atom[i], current_atom_size); + trak->stsd_size = current_atom_size; + trak->stsd = xine_xmalloc (current_atom_size); + + /* awful, awful hack to support a certain type of stsd atom that + * contains more than 1 video description atom */ + if (BE_32(&trak_atom[i + 8]) == 1) { + /* normal case */ + memcpy (trak->stsd, &trak_atom[i], current_atom_size); + hack_adjust = 0; + } else { + /* pathological case; take this route until a more definite + * solution is found: jump over the first atom video + * description atom */ + + /* copy the first 12 bytes since those remain the same */ + memcpy (trak->stsd, &trak_atom[i], 12); + + /* skip to the second atom and copy it */ + hack_adjust = BE_32(&trak_atom[i + 0x0C]); + memcpy(trak->stsd + 12, &trak_atom[i + 0x0C + hack_adjust], + BE_32(&trak_atom[i + 0x0C + hack_adjust])); + + /* use this variable to reference into the second atom, and + * fix at the end of the stsd parser */ + i += hack_adjust; + } - if (sample_table->type == MEDIA_VIDEO) { + if (trak->type == MEDIA_VIDEO) { /* initialize to sane values */ - sample_table->media_description.video.width = 0; - sample_table->media_description.video.height = 0; - sample_table->media_description.video.depth = 0; + trak->properties.video.width = 0; + trak->properties.video.height = 0; + trak->properties.video.depth = 0; /* assume no palette at first */ - sample_table->media_description.video.palette_count = 0; + trak->properties.video.palette_count = 0; /* fetch video parameters */ - if( BE_16(&trak_atom[i + 0x2C]) && BE_16(&trak_atom[i + 0x2E]) ) { - sample_table->media_description.video.width = + if( BE_16(&trak_atom[i + 0x2C]) && + BE_16(&trak_atom[i + 0x2E]) ) { + trak->properties.video.width = BE_16(&trak_atom[i + 0x2C]); - sample_table->media_description.video.height = + trak->properties.video.height = BE_16(&trak_atom[i + 0x2E]); } - sample_table->media_description.video.codec_format = + trak->properties.video.codec_fourcc = ME_32(&trak_atom[i + 0x10]); /* figure out the palette situation */ color_depth = trak_atom[i + 0x5F]; - sample_table->media_description.video.depth = color_depth; + trak->properties.video.depth = color_depth; color_greyscale = color_depth & 0x20; color_depth &= 0x1F; @@ -827,20 +800,20 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, if (color_greyscale) { - sample_table->media_description.video.palette_count = + trak->properties.video.palette_count = 1 << color_depth; /* compute the greyscale palette */ color_index = 255; color_dec = 256 / - (sample_table->media_description.video.palette_count - 1); + (trak->properties.video.palette_count - 1); for (j = 0; - j < sample_table->media_description.video.palette_count; + j < trak->properties.video.palette_count; j++) { - sample_table->media_description.video.palette[j].r = color_index; - sample_table->media_description.video.palette[j].g = color_index; - sample_table->media_description.video.palette[j].b = color_index; + trak->properties.video.palette[j].r = color_index; + trak->properties.video.palette[j].g = color_index; + trak->properties.video.palette[j].b = color_index; color_index -= color_dec; if (color_index < 0) color_index = 0; @@ -849,7 +822,7 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, } else if (color_flag & 0x08) { /* if flag bit 3 is set, load the default palette */ - sample_table->media_description.video.palette_count = + trak->properties.video.palette_count = 1 << color_depth; if (color_depth == 2) @@ -860,14 +833,14 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, color_table = qt_default_palette_256; for (j = 0; - j < sample_table->media_description.video.palette_count; + j < trak->properties.video.palette_count; j++) { - sample_table->media_description.video.palette[j].r = + trak->properties.video.palette[j].r = color_table[j * 4 + 0]; - sample_table->media_description.video.palette[j].g = + trak->properties.video.palette[j].g = color_table[j * 4 + 1]; - sample_table->media_description.video.palette[j].b = + trak->properties.video.palette[j].b = color_table[j * 4 + 2]; } @@ -878,7 +851,7 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, color_start = BE_32(&trak_atom[i + 0x62]); color_count = BE_16(&trak_atom[i + 0x66]); color_end = BE_16(&trak_atom[i + 0x68]); - sample_table->media_description.video.palette_count = + trak->properties.video.palette_count = color_end + 1; for (j = color_start; j <= color_end; j++) { @@ -887,23 +860,23 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, if (color_count & 0x8000) color_index = j; if (color_index < - sample_table->media_description.video.palette_count) { - sample_table->media_description.video.palette[color_index].r = + trak->properties.video.palette_count) { + trak->properties.video.palette[color_index].r = trak_atom[i + 0x6A + j * 8 + 2]; - sample_table->media_description.video.palette[color_index].g = + trak->properties.video.palette[color_index].g = trak_atom[i + 0x6A + j * 8 + 4]; - sample_table->media_description.video.palette[color_index].b = + trak->properties.video.palette[color_index].b = trak_atom[i + 0x6A + j * 8 + 6]; } } } } else - sample_table->media_description.video.palette_count = 0; + trak->properties.video.palette_count = 0; debug_atom_load(" video description\n"); debug_atom_load(" %dx%d, video fourcc = '%c%c%c%c' (%02X%02X%02X%02X)\n", - sample_table->media_description.video.width, - sample_table->media_description.video.height, + trak->properties.video.width, + trak->properties.video.height, trak_atom[i + 0x10], trak_atom[i + 0x11], trak_atom[i + 0x12], @@ -913,45 +886,48 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, trak_atom[i + 0x12], trak_atom[i + 0x13]); debug_atom_load(" %d RGB colors\n", - sample_table->media_description.video.palette_count); - for (j = 0; j < sample_table->media_description.video.palette_count; + trak->properties.video.palette_count); + for (j = 0; j < trak->properties.video.palette_count; j++) debug_atom_load(" %d: %3d %3d %3d\n", j, - sample_table->media_description.video.palette[j].r, - sample_table->media_description.video.palette[j].g, - sample_table->media_description.video.palette[j].b); + trak->properties.video.palette[j].r, + trak->properties.video.palette[j].g, + trak->properties.video.palette[j].b); - } else if (sample_table->type == MEDIA_AUDIO) { + } else if (trak->type == MEDIA_AUDIO) { /* fetch audio parameters */ - sample_table->media_description.audio.codec_format = + trak->properties.audio.codec_fourcc = ME_32(&trak_atom[i + 0x10]); - sample_table->media_description.audio.sample_rate = + trak->properties.audio.sample_rate = BE_16(&trak_atom[i + 0x2C]); - sample_table->media_description.audio.channels = trak_atom[i + 0x25]; - sample_table->media_description.audio.bits = trak_atom[i + 0x27]; + trak->properties.audio.channels = trak_atom[i + 0x25]; + trak->properties.audio.bits = trak_atom[i + 0x27]; /* assume uncompressed audio parameters */ - sample_table->bytes_per_sample = - sample_table->media_description.audio.bits / 8; - sample_table->samples_per_frame = - sample_table->media_description.audio.channels; - sample_table->bytes_per_frame = - sample_table->bytes_per_sample * sample_table->samples_per_frame; - sample_table->samples_per_packet = sample_table->samples_per_frame; - sample_table->bytes_per_packet = sample_table->bytes_per_sample; + trak->properties.audio.bytes_per_sample = + trak->properties.audio.bits / 8; + trak->properties.audio.samples_per_frame = + trak->properties.audio.channels; + trak->properties.audio.bytes_per_frame = + trak->properties.audio.bytes_per_sample * + trak->properties.audio.samples_per_frame; + trak->properties.audio.samples_per_packet = + trak->properties.audio.samples_per_frame; + trak->properties.audio.bytes_per_packet = + trak->properties.audio.bytes_per_sample; /* special case time: some ima4-encoded files don't have the * extra header; compensate */ if (BE_32(&trak_atom[i + 0x10]) == IMA4_FOURCC) { - sample_table->samples_per_packet = 64; - sample_table->bytes_per_packet = 34; - sample_table->bytes_per_frame = 34 * - sample_table->media_description.audio.channels; - sample_table->bytes_per_sample = 2; - sample_table->samples_per_frame = 64 * - sample_table->media_description.audio.channels; + trak->properties.audio.samples_per_packet = 64; + trak->properties.audio.bytes_per_packet = 34; + trak->properties.audio.bytes_per_frame = 34 * + trak->properties.audio.channels; + trak->properties.audio.bytes_per_sample = 2; + trak->properties.audio.samples_per_frame = 64 * + trak->properties.audio.channels; } /* it's time to dig a little deeper to determine the real audio @@ -961,47 +937,52 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, if (BE_32(&trak_atom[i + 0x0C]) > 0x24) { if (BE_32(&trak_atom[i + 0x30])) - sample_table->samples_per_packet = BE_32(&trak_atom[i + 0x30]); + trak->properties.audio.samples_per_packet = + BE_32(&trak_atom[i + 0x30]); if (BE_32(&trak_atom[i + 0x34])) - sample_table->bytes_per_packet = BE_32(&trak_atom[i + 0x34]); + trak->properties.audio.bytes_per_packet = + BE_32(&trak_atom[i + 0x34]); if (BE_32(&trak_atom[i + 0x38])) - sample_table->bytes_per_frame = BE_32(&trak_atom[i + 0x38]); + trak->properties.audio.bytes_per_frame = + BE_32(&trak_atom[i + 0x38]); if (BE_32(&trak_atom[i + 0x3C])) - sample_table->bytes_per_sample = BE_32(&trak_atom[i + 0x3C]); - sample_table->samples_per_frame = - (sample_table->bytes_per_frame / sample_table->bytes_per_packet) * - sample_table->samples_per_packet; + trak->properties.audio.bytes_per_sample = + BE_32(&trak_atom[i + 0x3C]); + trak->properties.audio.samples_per_frame = + (trak->properties.audio.bytes_per_frame / + trak->properties.audio.bytes_per_packet) * + trak->properties.audio.samples_per_packet; } /* see if the trak deserves a promotion to VBR */ if (BE_16(&trak_atom[i + 0x28]) == 0xFFFE) - sample_table->media_description.audio.vbr = 1; + trak->properties.audio.vbr = 1; else - sample_table->media_description.audio.vbr = 0; + trak->properties.audio.vbr = 0; - /* if this is MP4 audio, mark it as VBR */ + /* if this is MP4 audio, mark the trak as VBR */ if (BE_32(&trak_atom[i + 0x10]) == MP4A_FOURCC) - sample_table->media_description.audio.vbr = 1; + trak->properties.audio.vbr = 1; /* check for a MS-style WAVE format header */ if ((current_atom_size >= 0x48) && (BE_32(&trak_atom[i + 0x44]) == WAVE_ATOM)) { - sample_table->media_description.audio.wave_present = 1; - memcpy(&sample_table->media_description.audio.wave, + trak->properties.audio.wave_present = 1; + memcpy(&trak->properties.audio.wave, &trak_atom[i + 0x5C], - sizeof(sample_table->media_description.audio.wave)); - xine_waveformatex_le2me(&sample_table->media_description.audio.wave); + sizeof(trak->properties.audio.wave)); + xine_waveformatex_le2me(&trak->properties.audio.wave); } else { - sample_table->media_description.audio.wave_present = 0; + trak->properties.audio.wave_present = 0; } debug_atom_load(" audio description\n"); debug_atom_load(" %d Hz, %d bits, %d channels, %saudio fourcc = '%c%c%c%c' (%02X%02X%02X%02X)\n", - sample_table->media_description.audio.sample_rate, - sample_table->media_description.audio.bits, - sample_table->media_description.audio.channels, - (sample_table->media_description.audio.vbr) ? "vbr, " : "", + trak->properties.audio.sample_rate, + trak->properties.audio.bits, + trak->properties.audio.channels, + (trak->properties.audio.vbr) ? "vbr, " : "", trak_atom[i + 0x10], trak_atom[i + 0x11], trak_atom[i + 0x12], @@ -1012,23 +993,25 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, trak_atom[i + 0x13]); if (BE_32(&trak_atom[i + 0x0C]) > 0x24) { debug_atom_load(" %d samples/packet, %d bytes/packet, %d bytes/frame\n", - sample_table->samples_per_packet, - sample_table->bytes_per_packet, - sample_table->bytes_per_frame); + trak->properties.audio.samples_per_packet, + trak->properties.audio.bytes_per_packet, + trak->properties.audio.bytes_per_frame); debug_atom_load(" %d bytes/sample (%d samples/frame)\n", - sample_table->bytes_per_sample, - sample_table->samples_per_frame); + trak->properties.audio.bytes_per_sample, + trak->properties.audio.samples_per_frame); } } + i -= hack_adjust; + } else if (current_atom == ESDS_ATOM) { uint32_t len; debug_atom_load(" qt/mpeg-4 esds atom\n"); - if ((sample_table->type == MEDIA_VIDEO) || - (sample_table->type == MEDIA_AUDIO)) { + if ((trak->type == MEDIA_VIDEO) || + (trak->type == MEDIA_AUDIO)) { j = i + 8; if( trak_atom[j++] == 0x03 ) { @@ -1043,9 +1026,9 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, j += mp4_read_descr_len( &trak_atom[j], &len ); debug_atom_load(" decoder config is %d (0x%X) bytes long\n", len, len); - sample_table->decoder_config = malloc(len); - sample_table->decoder_config_len = len; - memcpy(sample_table->decoder_config,&trak_atom[j],len); + trak->decoder_config = malloc(len); + trak->decoder_config_len = len; + memcpy(trak->decoder_config,&trak_atom[j],len); } } } @@ -1053,205 +1036,205 @@ static qt_error parse_trak_atom (qt_sample_table *sample_table, } else if (current_atom == STSZ_ATOM) { /* there should only be one of these atoms */ - if (sample_table->sample_size_table) { + if (trak->sample_size_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->sample_size = BE_32(&trak_atom[i + 8]); - sample_table->sample_size_count = BE_32(&trak_atom[i + 12]); + trak->sample_size = BE_32(&trak_atom[i + 8]); + trak->sample_size_count = BE_32(&trak_atom[i + 12]); debug_atom_load(" qt stsz atom (sample size atom): sample size = %d, %d entries\n", - sample_table->sample_size, sample_table->sample_size_count); + trak->sample_size, trak->sample_size_count); /* allocate space and load table only if sample size is 0 */ - if (sample_table->sample_size == 0) { - sample_table->sample_size_table = (unsigned int *)malloc( - sample_table->sample_size_count * sizeof(unsigned int)); - if (!sample_table->sample_size_table) { + if (trak->sample_size == 0) { + trak->sample_size_table = (unsigned int *)malloc( + trak->sample_size_count * sizeof(unsigned int)); + if (!trak->sample_size_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the sample size table */ - for (j = 0; j < sample_table->sample_size_count; j++) { - sample_table->sample_size_table[j] = + for (j = 0; j < trak->sample_size_count; j++) { + trak->sample_size_table[j] = BE_32(&trak_atom[i + 16 + j * 4]); debug_atom_load(" sample size %d: %d\n", - j, sample_table->sample_size_table[j]); + j, trak->sample_size_table[j]); } } else /* set the pointer to non-NULL to indicate that the atom type has * already been seen for this trak atom */ - sample_table->sample_size_table = (void *)-1; + trak->sample_size_table = (void *)-1; } else if (current_atom == STSS_ATOM) { /* there should only be one of these atoms */ - if (sample_table->sync_sample_table) { + if (trak->sync_sample_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->sync_sample_count = BE_32(&trak_atom[i + 8]); + trak->sync_sample_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt stss atom (sample sync atom): %d sync samples\n", - sample_table->sync_sample_count); + trak->sync_sample_count); - sample_table->sync_sample_table = (unsigned int *)malloc( - sample_table->sync_sample_count * sizeof(unsigned int)); - if (!sample_table->sync_sample_table) { + trak->sync_sample_table = (unsigned int *)malloc( + trak->sync_sample_count * sizeof(unsigned int)); + if (!trak->sync_sample_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the sync sample table */ - for (j = 0; j < sample_table->sync_sample_count; j++) { - sample_table->sync_sample_table[j] = + for (j = 0; j < trak->sync_sample_count; j++) { + trak->sync_sample_table[j] = BE_32(&trak_atom[i + 12 + j * 4]); debug_atom_load(" sync sample %d: sample %d (%d) is a keyframe\n", - j, sample_table->sync_sample_table[j], - sample_table->sync_sample_table[j] - 1); + j, trak->sync_sample_table[j], + trak->sync_sample_table[j] - 1); } } else if (current_atom == STCO_ATOM) { /* there should only be one of either stco or co64 */ - if (sample_table->chunk_offset_table) { + if (trak->chunk_offset_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->chunk_offset_count = BE_32(&trak_atom[i + 8]); + trak->chunk_offset_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt stco atom (32-bit chunk offset atom): %d chunk offsets\n", - sample_table->chunk_offset_count); + trak->chunk_offset_count); - sample_table->chunk_offset_table = (int64_t *)malloc( - sample_table->chunk_offset_count * sizeof(int64_t)); - if (!sample_table->chunk_offset_table) { + trak->chunk_offset_table = (int64_t *)malloc( + trak->chunk_offset_count * sizeof(int64_t)); + if (!trak->chunk_offset_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the chunk offset table */ - for (j = 0; j < sample_table->chunk_offset_count; j++) { - sample_table->chunk_offset_table[j] = + for (j = 0; j < trak->chunk_offset_count; j++) { + trak->chunk_offset_table[j] = BE_32(&trak_atom[i + 12 + j * 4]); debug_atom_load(" chunk %d @ 0x%llX\n", - j, sample_table->chunk_offset_table[j]); + j, trak->chunk_offset_table[j]); } } else if (current_atom == CO64_ATOM) { /* there should only be one of either stco or co64 */ - if (sample_table->chunk_offset_table) { + if (trak->chunk_offset_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->chunk_offset_count = BE_32(&trak_atom[i + 8]); + trak->chunk_offset_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt co64 atom (64-bit chunk offset atom): %d chunk offsets\n", - sample_table->chunk_offset_count); + trak->chunk_offset_count); - sample_table->chunk_offset_table = (int64_t *)malloc( - sample_table->chunk_offset_count * sizeof(int64_t)); - if (!sample_table->chunk_offset_table) { + trak->chunk_offset_table = (int64_t *)malloc( + trak->chunk_offset_count * sizeof(int64_t)); + if (!trak->chunk_offset_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the 64-bit chunk offset table */ - for (j = 0; j < sample_table->chunk_offset_count; j++) { - sample_table->chunk_offset_table[j] = + for (j = 0; j < trak->chunk_offset_count; j++) { + trak->chunk_offset_table[j] = BE_32(&trak_atom[i + 12 + j * 8 + 0]); - sample_table->chunk_offset_table[j] <<= 32; - sample_table->chunk_offset_table[j] |= + trak->chunk_offset_table[j] <<= 32; + trak->chunk_offset_table[j] |= BE_32(&trak_atom[i + 12 + j * 8 + 4]); debug_atom_load(" chunk %d @ 0x%llX\n", - j, sample_table->chunk_offset_table[j]); + j, trak->chunk_offset_table[j]); } } else if (current_atom == STSC_ATOM) { /* there should only be one of these atoms */ - if (sample_table->sample_to_chunk_table) { + if (trak->sample_to_chunk_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->sample_to_chunk_count = BE_32(&trak_atom[i + 8]); + trak->sample_to_chunk_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt stsc atom (sample-to-chunk atom): %d entries\n", - sample_table->sample_to_chunk_count); + trak->sample_to_chunk_count); - sample_table->sample_to_chunk_table = (sample_to_chunk_table_t *)malloc( - sample_table->sample_to_chunk_count * sizeof(sample_to_chunk_table_t)); - if (!sample_table->sample_to_chunk_table) { + trak->sample_to_chunk_table = (sample_to_chunk_table_t *)malloc( + trak->sample_to_chunk_count * sizeof(sample_to_chunk_table_t)); + if (!trak->sample_to_chunk_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the sample to chunk table */ - for (j = 0; j < sample_table->sample_to_chunk_count; j++) { - sample_table->sample_to_chunk_table[j].first_chunk = + for (j = 0; j < trak->sample_to_chunk_count; j++) { + trak->sample_to_chunk_table[j].first_chunk = BE_32(&trak_atom[i + 12 + j * 12 + 0]); - sample_table->sample_to_chunk_table[j].samples_per_chunk = + trak->sample_to_chunk_table[j].samples_per_chunk = BE_32(&trak_atom[i + 12 + j * 12 + 4]); debug_atom_load(" %d: %d samples/chunk starting at chunk %d (%d)\n", - j, sample_table->sample_to_chunk_table[j].samples_per_chunk, - sample_table->sample_to_chunk_table[j].first_chunk, - sample_table->sample_to_chunk_table[j].first_chunk - 1); + j, trak->sample_to_chunk_table[j].samples_per_chunk, + trak->sample_to_chunk_table[j].first_chunk, + trak->sample_to_chunk_table[j].first_chunk - 1); } } else if (current_atom == STTS_ATOM) { /* there should only be one of these atoms */ - if (sample_table->time_to_sample_table) { + if (trak->time_to_sample_table) { last_error = QT_HEADER_TROUBLE; - goto free_sample_table; + goto free_trak; } - sample_table->time_to_sample_count = BE_32(&trak_atom[i + 8]); + trak->time_to_sample_count = BE_32(&trak_atom[i + 8]); debug_atom_load(" qt stts atom (time-to-sample atom): %d entries\n", - sample_table->time_to_sample_count); + trak->time_to_sample_count); - sample_table->time_to_sample_table = (time_to_sample_table_t *)malloc( - (sample_table->time_to_sample_count+1) * sizeof(time_to_sample_table_t)); - if (!sample_table->time_to_sample_table) { + trak->time_to_sample_table = (time_to_sample_table_t *)malloc( + (trak->time_to_sample_count+1) * sizeof(time_to_sample_table_t)); + if (!trak->time_to_sample_table) { last_error = QT_NO_MEMORY; - goto free_sample_table; + goto free_trak; } /* load the time to sample table */ - for (j = 0; j < sample_table->time_to_sample_count; j++) { - sample_table->time_to_sample_table[j].count = + for (j = 0; j < trak->time_to_sample_count; j++) { + trak->time_to_sample_table[j].count = BE_32(&trak_atom[i + 12 + j * 8 + 0]); - sample_table->time_to_sample_table[j].duration = + trak->time_to_sample_table[j].duration = BE_32(&trak_atom[i + 12 + j * 8 + 4]); debug_atom_load(" %d: count = %d, duration = %d\n", - j, sample_table->time_to_sample_table[j].count, - sample_table->time_to_sample_table[j].duration); + j, trak->time_to_sample_table[j].count, + trak->time_to_sample_table[j].duration); } - sample_table->time_to_sample_table[j].count = 0; /* terminate with zero */ + trak->time_to_sample_table[j].count = 0; /* terminate with zero */ } } return QT_OK; /* jump here to make sure everything is free'd and avoid leaking memory */ -free_sample_table: - free(sample_table->edit_list_table); - free(sample_table->chunk_offset_table); +free_trak: + free(trak->edit_list_table); + free(trak->chunk_offset_table); /* this pointer might have been set to -1 as a special case */ - if (sample_table->sample_size_table != (void *)-1) - free(sample_table->sample_size_table); - free(sample_table->sync_sample_table); - free(sample_table->sample_to_chunk_table); - free(sample_table->time_to_sample_table); - free(sample_table->decoder_config); - free(sample_table->stsd); + if (trak->sample_size_table != (void *)-1) + free(trak->sample_size_table); + free(trak->sync_sample_table); + free(trak->sample_to_chunk_table); + free(trak->time_to_sample_table); + free(trak->decoder_config); + free(trak->stsd); return last_error; } @@ -1259,32 +1242,32 @@ free_sample_table: /* This is a little support function used to process the edit list when * building a frame table. */ #define MAX_DURATION 0x7FFFFFFFFFFFFFFF -static void get_next_edit_list_entry(qt_sample_table *sample_table, +static void get_next_edit_list_entry(qt_trak *trak, int *edit_list_index, unsigned int *edit_list_media_time, int64_t *edit_list_duration, unsigned int global_timescale) { /* if there is no edit list, set to max duration and get out */ - if (!sample_table->edit_list_table) { + if (!trak->edit_list_table) { *edit_list_media_time = 0; *edit_list_duration = MAX_DURATION; debug_edit_list(" qt: no edit list table, initial = %d, %lld\n", *edit_list_media_time, *edit_list_duration); return; - } else while (*edit_list_index < sample_table->edit_list_count) { + } else while (*edit_list_index < trak->edit_list_count) { /* otherwise, find an edit list entries whose media time != -1 */ - if (sample_table->edit_list_table[*edit_list_index].media_time != -1) { + if (trak->edit_list_table[*edit_list_index].media_time != -1) { *edit_list_media_time = - sample_table->edit_list_table[*edit_list_index].media_time; + trak->edit_list_table[*edit_list_index].media_time; *edit_list_duration = - sample_table->edit_list_table[*edit_list_index].track_duration; + trak->edit_list_table[*edit_list_index].track_duration; /* duration is in global timescale units; convert to trak timescale */ - *edit_list_duration *= sample_table->timescale; + *edit_list_duration *= trak->timescale; *edit_list_duration /= global_timescale; *edit_list_index = *edit_list_index + 1; @@ -1297,12 +1280,12 @@ static void get_next_edit_list_entry(qt_sample_table *sample_table, /* on the way out, check if this is the last edit list entry; if so, * don't let the duration expire (so set it to an absurdly large value) */ - if (*edit_list_index == sample_table->edit_list_count) + if (*edit_list_index == trak->edit_list_count) *edit_list_duration = MAX_DURATION; debug_edit_list(" qt: edit list table exists, initial = %d, %lld\n", *edit_list_media_time, *edit_list_duration); } -static qt_error build_frame_table(qt_sample_table *sample_table, +static qt_error build_frame_table(qt_trak *trak, unsigned int global_timescale) { int i, j; @@ -1322,15 +1305,15 @@ static qt_error build_frame_table(qt_sample_table *sample_table, /* AUDIO and OTHER frame types follow the same rules; VIDEO and vbr audio * frame types follow a different set */ - if ((sample_table->type == MEDIA_VIDEO) || - (sample_table->media_description.audio.vbr)) { + if ((trak->type == MEDIA_VIDEO) || + (trak->properties.audio.vbr)) { /* in this case, the total number of frames is equal to the number of * entries in the sample size table */ - sample_table->frame_count = sample_table->sample_size_count; - sample_table->frames = (qt_frame *)malloc( - sample_table->frame_count * sizeof(qt_frame)); - if (!sample_table->frames) + trak->frame_count = trak->sample_size_count; + trak->frames = (qt_frame *)malloc( + trak->frame_count * sizeof(qt_frame)); + if (!trak->frames) return QT_NO_MEMORY; /* initialize more accounting variables */ @@ -1338,60 +1321,59 @@ static qt_error build_frame_table(qt_sample_table *sample_table, current_pts = 0; pts_index = 0; pts_index_countdown = - sample_table->time_to_sample_table[pts_index].count; + trak->time_to_sample_table[pts_index].count; /* iterate through each start chunk in the stsc table */ - for (i = 0; i < sample_table->sample_to_chunk_count; i++) { + for (i = 0; i < trak->sample_to_chunk_count; i++) { /* iterate from the first chunk of the current table entry to * the first chunk of the next table entry */ - chunk_start = sample_table->sample_to_chunk_table[i].first_chunk; - if (i < sample_table->sample_to_chunk_count - 1) + chunk_start = trak->sample_to_chunk_table[i].first_chunk; + if (i < trak->sample_to_chunk_count - 1) chunk_end = - sample_table->sample_to_chunk_table[i + 1].first_chunk; + trak->sample_to_chunk_table[i + 1].first_chunk; else /* if the first chunk is in the last table entry, iterate to the final chunk number (the number of offsets in stco table) */ - chunk_end = sample_table->chunk_offset_count + 1; + chunk_end = trak->chunk_offset_count + 1; /* iterate through each sample in a chunk */ for (j = chunk_start - 1; j < chunk_end - 1; j++) { samples_per_chunk = - sample_table->sample_to_chunk_table[i].samples_per_chunk; - current_offset = sample_table->chunk_offset_table[j]; + trak->sample_to_chunk_table[i].samples_per_chunk; + current_offset = trak->chunk_offset_table[j]; while (samples_per_chunk > 0) { - sample_table->frames[frame_counter].type = sample_table->type; /* figure out the offset and size */ - sample_table->frames[frame_counter].offset = current_offset; - if (sample_table->sample_size) { - sample_table->frames[frame_counter].size = - sample_table->sample_size; - current_offset += sample_table->sample_size; + trak->frames[frame_counter].offset = current_offset; + if (trak->sample_size) { + trak->frames[frame_counter].size = + trak->sample_size; + current_offset += trak->sample_size; } else { - sample_table->frames[frame_counter].size = - sample_table->sample_size_table[frame_counter]; + trak->frames[frame_counter].size = + trak->sample_size_table[frame_counter]; current_offset += - sample_table->sample_size_table[frame_counter]; + trak->sample_size_table[frame_counter]; } /* if there is no stss (sample sync) table, make all of the frames * keyframes; otherwise, clear the keyframe bits for now */ - if (sample_table->sync_sample_table) - sample_table->frames[frame_counter].keyframe = 0; + if (trak->sync_sample_table) + trak->frames[frame_counter].keyframe = 0; else - sample_table->frames[frame_counter].keyframe = 1; + trak->frames[frame_counter].keyframe = 1; /* figure out the pts situation */ - sample_table->frames[frame_counter].pts = current_pts; + trak->frames[frame_counter].pts = current_pts; current_pts += - sample_table->time_to_sample_table[pts_index].duration; + trak->time_to_sample_table[pts_index].duration; pts_index_countdown--; /* time to refresh countdown? */ if (!pts_index_countdown) { pts_index++; pts_index_countdown = - sample_table->time_to_sample_table[pts_index].count; + trak->time_to_sample_table[pts_index].count; } samples_per_chunk--; @@ -1401,117 +1383,115 @@ static qt_error build_frame_table(qt_sample_table *sample_table, } /* fill in the keyframe information */ - if (sample_table->sync_sample_table) { - for (i = 0; i < sample_table->sync_sample_count; i++) - sample_table->frames[sample_table->sync_sample_table[i] - 1].keyframe = 1; + if (trak->sync_sample_table) { + for (i = 0; i < trak->sync_sample_count; i++) + trak->frames[trak->sync_sample_table[i] - 1].keyframe = 1; } /* initialize edit list considerations */ edit_list_index = 0; - get_next_edit_list_entry(sample_table, &edit_list_index, + get_next_edit_list_entry(trak, &edit_list_index, &edit_list_media_time, &edit_list_duration, global_timescale); /* fix up pts information w.r.t. the edit list table */ edit_list_pts_counter = 0; - for (i = 0; i < sample_table->frame_count; i++) { + for (i = 0; i < trak->frame_count; i++) { - debug_edit_list(" %d: (before) pts = %lld...", i, sample_table->frames[i].pts); + debug_edit_list(" %d: (before) pts = %lld...", i, trak->frames[i].pts); - if (sample_table->frames[i].pts < edit_list_media_time) - sample_table->frames[i].pts = edit_list_pts_counter; + if (trak->frames[i].pts < edit_list_media_time) + trak->frames[i].pts = edit_list_pts_counter; else { - if (i < sample_table->frame_count - 1) + if (i < trak->frame_count - 1) frame_duration = - (sample_table->frames[i + 1].pts - sample_table->frames[i].pts); + (trak->frames[i + 1].pts - trak->frames[i].pts); debug_edit_list("duration = %lld...", frame_duration); - sample_table->frames[i].pts = edit_list_pts_counter; + trak->frames[i].pts = edit_list_pts_counter; edit_list_pts_counter += frame_duration; edit_list_duration -= frame_duration; } - debug_edit_list("(fixup) pts = %lld...", sample_table->frames[i].pts); + debug_edit_list("(fixup) pts = %lld...", trak->frames[i].pts); /* reload media time and duration */ if (edit_list_duration <= 0) { - get_next_edit_list_entry(sample_table, &edit_list_index, + get_next_edit_list_entry(trak, &edit_list_index, &edit_list_media_time, &edit_list_duration, global_timescale); } - debug_edit_list("(after) pts = %lld...\n", sample_table->frames[i].pts); + debug_edit_list("(after) pts = %lld...\n", trak->frames[i].pts); } /* compute final pts values */ - for (i = 0; i < sample_table->frame_count; i++) { - sample_table->frames[i].pts *= 90000; - sample_table->frames[i].pts /= sample_table->timescale; - debug_edit_list(" final pts for sample %d = %lld\n", i, sample_table->frames[i].pts); + for (i = 0; i < trak->frame_count; i++) { + trak->frames[i].pts *= 90000; + trak->frames[i].pts /= trak->timescale; + debug_edit_list(" final pts for sample %d = %lld\n", i, trak->frames[i].pts); } } else { /* in this case, the total number of frames is equal to the number of * chunks */ - sample_table->frame_count = sample_table->chunk_offset_count; - sample_table->frames = (qt_frame *)malloc( - sample_table->frame_count * sizeof(qt_frame)); - if (!sample_table->frames) + trak->frame_count = trak->chunk_offset_count; + trak->frames = (qt_frame *)malloc( + trak->frame_count * sizeof(qt_frame)); + if (!trak->frames) return QT_NO_MEMORY; - if (sample_table->type == MEDIA_AUDIO) { + if (trak->type == MEDIA_AUDIO) { /* iterate through each start chunk in the stsc table */ - for (i = 0; i < sample_table->sample_to_chunk_count; i++) { + for (i = 0; i < trak->sample_to_chunk_count; i++) { /* iterate from the first chunk of the current table entry to * the first chunk of the next table entry */ - chunk_start = sample_table->sample_to_chunk_table[i].first_chunk; - if (i < sample_table->sample_to_chunk_count - 1) + chunk_start = trak->sample_to_chunk_table[i].first_chunk; + if (i < trak->sample_to_chunk_count - 1) chunk_end = - sample_table->sample_to_chunk_table[i + 1].first_chunk; + trak->sample_to_chunk_table[i + 1].first_chunk; else /* if the first chunk is in the last table entry, iterate to the final chunk number (the number of offsets in stco table) */ - chunk_end = sample_table->chunk_offset_count + 1; + chunk_end = trak->chunk_offset_count + 1; /* iterate through each sample in a chunk and fill in size and * pts information */ for (j = chunk_start - 1; j < chunk_end - 1; j++) { /* figure out the pts for this chunk */ - sample_table->frames[j].pts = audio_frame_counter; - sample_table->frames[j].pts *= 90000; - sample_table->frames[j].pts /= sample_table->timescale; + trak->frames[j].pts = audio_frame_counter; + trak->frames[j].pts *= 90000; + trak->frames[j].pts /= trak->timescale; /* fetch the alleged chunk size according to the QT header */ - sample_table->frames[j].size = - sample_table->sample_to_chunk_table[i].samples_per_chunk; + trak->frames[j].size = + trak->sample_to_chunk_table[i].samples_per_chunk; /* the chunk size is actually the audio frame count */ - audio_frame_counter += sample_table->frames[j].size; + audio_frame_counter += trak->frames[j].size; /* compute the actual chunk size */ - sample_table->frames[j].size = - (sample_table->frames[j].size * - sample_table->media_description.audio.channels) / - sample_table->samples_per_frame * - sample_table->bytes_per_frame; + trak->frames[j].size = + (trak->frames[j].size * + trak->properties.audio.channels) / + trak->properties.audio.samples_per_frame * + trak->properties.audio.bytes_per_frame; } } } /* fill in the rest of the information for the audio samples */ - for (i = 0; i < sample_table->frame_count; i++) { - sample_table->frames[i].type = sample_table->type; - sample_table->frames[i].offset = sample_table->chunk_offset_table[i]; - sample_table->frames[i].keyframe = 0; - if (sample_table->type != MEDIA_AUDIO) - sample_table->frames[i].pts = 0; + for (i = 0; i < trak->frame_count; i++) { + trak->frames[i].offset = trak->chunk_offset_table[i]; + trak->frames[i].keyframe = 0; + if (trak->type != MEDIA_AUDIO) + trak->frames[i].pts = 0; } } return QT_OK; } - /* * This function takes a pointer to a qt_info structure and a pointer to * a buffer containing an uncompressed moov atom. When the function @@ -1519,15 +1499,12 @@ static qt_error build_frame_table(qt_sample_table *sample_table, * ordered by offset. */ static void parse_moov_atom(qt_info *info, unsigned char *moov_atom) { - int i, j; + int i; unsigned int moov_atom_size = BE_32(&moov_atom[0]); - unsigned int sample_table_count = 0; - qt_sample_table *sample_tables = NULL; qt_atom current_atom; - unsigned int *sample_table_indices; - unsigned int min_offset_table; - int64_t min_offset; int string_size; + unsigned int max_video_frames = 0; + unsigned int max_audio_frames = 0; /* make sure this is actually a moov atom */ if (BE_32(&moov_atom[4]) != MOOV_ATOM) { @@ -1546,13 +1523,12 @@ static void parse_moov_atom(qt_info *info, unsigned char *moov_atom) { i += BE_32(&moov_atom[i - 4]) - 4; } else if (current_atom == TRAK_ATOM) { - /* make a new sample temporary sample table */ - sample_table_count++; - sample_tables = (qt_sample_table *)realloc(sample_tables, - sample_table_count * sizeof(qt_sample_table)); + /* create a new trak structure */ + info->trak_count++; + info->traks = (qt_trak *)realloc(info->traks, + info->trak_count * sizeof(qt_trak)); - parse_trak_atom (&sample_tables[sample_table_count - 1], - &moov_atom[i - 4]); + parse_trak_atom (&info->traks[info->trak_count - 1], &moov_atom[i - 4]); if (info->last_error != QT_OK) return; i += BE_32(&moov_atom[i - 4]) - 4; @@ -1582,147 +1558,27 @@ static void parse_moov_atom(qt_info *info, unsigned char *moov_atom) { debug_atom_load(" qt: finished parsing moov atom\n"); /* build frame tables corresponding to each sample table */ - info->frame_count = 0; debug_frame_table(" qt: preparing to build %d frame tables\n", - sample_table_count); - for (i = 0; i < sample_table_count; i++) { + info->trak_count); + for (i = 0; i < info->trak_count; i++) { debug_frame_table(" qt: building frame table #%d\n", i); - build_frame_table(&sample_tables[i], info->timescale); - info->frame_count += sample_tables[i].frame_count; - - /* while traversing tables, look for A/V information */ - if (sample_tables[i].type == MEDIA_VIDEO) { + build_frame_table(&info->traks[i], info->timescale); - info->video_width = sample_tables[i].media_description.video.width; - info->video_height = sample_tables[i].media_description.video.height; - info->video_depth = sample_tables[i].media_description.video.depth; - info->video_codec = - sample_tables[i].media_description.video.codec_format; - - /* fixme: there may be multiple trak with decoder_config. - i don't know if we should choose one or concatenate everything? */ - if( sample_tables[i].frame_count > 1 && sample_tables[i].decoder_config ) { - info->video_decoder_config = sample_tables[i].decoder_config; - info->video_decoder_config_len = sample_tables[i].decoder_config_len; - } + /* decide which audio trak and which video trak has the most frames */ + if ((info->traks[i].type == MEDIA_VIDEO) && + (info->traks[i].frame_count > max_video_frames)) { - /* pass the palette info to the master qt_info structure */ - if (sample_tables[i].media_description.video.palette_count) { - info->palette_count = - sample_tables[i].media_description.video.palette_count; - memcpy(info->palette, - sample_tables[i].media_description.video.palette, - PALETTE_COUNT * sizeof(palette_entry_t)); - } + info->video_trak = i; + max_video_frames = info->traks[i].frame_count; - /* stsd atom */ - info->video_stsd = realloc (info->video_stsd, sample_tables[i].stsd_size); - info->video_stsd_size = sample_tables[i].stsd_size; - memcpy(info->video_stsd, sample_tables[i].stsd, info->video_stsd_size); - - } else if (sample_tables[i].type == MEDIA_AUDIO) { - - info->audio_sample_rate = - sample_tables[i].media_description.audio.sample_rate; - info->audio_channels = - sample_tables[i].media_description.audio.channels; - info->audio_bits = - sample_tables[i].media_description.audio.bits; - info->audio_codec = - sample_tables[i].media_description.audio.codec_format; - info->audio_vbr = - sample_tables[i].media_description.audio.vbr; - - info->audio_decoder_config = sample_tables[i].decoder_config; - info->audio_decoder_config_len = sample_tables[i].decoder_config_len; - - info->wave_present = - sample_tables[i].media_description.audio.wave_present; - memcpy(&info->wave, &sample_tables[i].media_description.audio.wave, - sizeof(xine_waveformatex)); - - /* stsd atom */ - info->audio_stsd = realloc (info->audio_stsd, sample_tables[i].stsd_size); - info->audio_stsd_size = sample_tables[i].stsd_size; - memcpy(info->audio_stsd, sample_tables[i].stsd, info->audio_stsd_size); - } - } - debug_frame_table(" qt: finished building frame tables, merging into one...\n"); - - /* allocate the master frame index */ - info->frames = (qt_frame *)malloc(info->frame_count * sizeof(qt_frame)); - if (!info->frames) { - info->last_error = QT_NO_MEMORY; - return; - } - - /* allocate and zero out space for table indices */ - sample_table_indices = (unsigned int *)malloc( - sample_table_count * sizeof(unsigned int)); - - if (!sample_table_indices) { - info->last_error = QT_NO_MEMORY; - return; - } - for (i = 0; i < sample_table_count; i++) { - if (sample_tables[i].frame_count == 0) - sample_table_indices[i] = 0x7FFFFFF; - else - sample_table_indices[i] = 0; - } + } else if ((info->traks[i].type == MEDIA_AUDIO) && + (info->traks[i].frame_count > max_audio_frames)) { - /* merge the tables, order by frame offset */ - for (i = 0; i < info->frame_count; i++) { - - /* get the table number of the smallest frame offset */ - min_offset_table = -1; - min_offset = 0; /* value not used (avoid compiler warnings) */ - for (j = 0; j < sample_table_count; j++) { - if ((sample_table_indices[j] < info->frame_count) && - (min_offset_table == -1 || - (sample_tables[j].frames[sample_table_indices[j]].offset < - min_offset) ) ) { - min_offset_table = j; - min_offset = sample_tables[j].frames[sample_table_indices[j]].offset; - } + info->audio_trak = i; + max_audio_frames = info->traks[i].frame_count; } - - info->frames[i] = - sample_tables[min_offset_table].frames[sample_table_indices[min_offset_table]]; - sample_table_indices[min_offset_table]++; - if (sample_table_indices[min_offset_table] >= - sample_tables[min_offset_table].frame_count) - sample_table_indices[min_offset_table] = info->frame_count; - } - - debug_frame_table(" qt: final frame table contains %d frames\n", - info->frame_count); - for (i = 0; i < info->frame_count; i++) - debug_frame_table(" %d: %s frame @ offset 0x%llX, 0x%X bytes, pts = %lld%s\n", - i, - (info->frames[i].type == MEDIA_VIDEO) ? "video" : - (info->frames[i].type == MEDIA_AUDIO) ? "audio" : "other", - info->frames[i].offset, - info->frames[i].size, - info->frames[i].pts, - (info->frames[i].keyframe) ? ", keyframe" : ""); - - /* free the temporary tables on the way out */ - for (i = 0; i < sample_table_count; i++) { - free(sample_tables[i].edit_list_table); - free(sample_tables[i].chunk_offset_table); - /* this pointer might have been set to -1 as a special case */ - if (sample_tables[i].sample_size_table != (void *)-1) - free(sample_tables[i].sample_size_table); - free(sample_tables[i].time_to_sample_table); - free(sample_tables[i].sample_to_chunk_table); - free(sample_tables[i].sync_sample_table); - free(sample_tables[i].frames); - free(sample_tables[i].stsd); } - free(sample_tables); - free(sample_table_indices); } static qt_error open_qt_file(qt_info *info, input_plugin_t *input) { @@ -1742,7 +1598,6 @@ static qt_error open_qt_file(qt_info *info, input_plugin_t *input) { return info->last_error; } info->moov_first_offset = moov_atom_offset; - info->moov_last_offset = info->moov_first_offset + moov_atom_size; moov_atom = (unsigned char *)malloc(moov_atom_size); if (moov_atom == NULL) { @@ -1839,55 +1694,121 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { buf_element_t *buf = NULL; unsigned int i, j; unsigned int remaining_sample_bytes; - int edit_list_compensation = 0; int frame_duration; int first_buf; + qt_trak *video_trak = NULL; + qt_trak *audio_trak = NULL; + int dispatch_audio; /* boolean for deciding which trak to dispatch */ + int64_t pts_diff; + + if (this->qt->video_trak != -1) { + video_trak = &this->qt->traks[this->qt->video_trak]; + } + if (this->qt->audio_trak != -1) { + audio_trak = &this->qt->traks[this->qt->audio_trak]; + } - i = this->current_frame; + /* check if it is time to seek */ + if (this->qt->seek_flag) { + this->qt->seek_flag = 0; - /* if there is an incongruency between last and current sample, it - * must be time to send a new pts */ - if (this->last_frame + 1 != this->current_frame) { - /* send new pts */ - xine_demux_control_newpts(this->stream, this->qt->frames[i].pts, - this->qt->frames[i].pts ? BUF_FLAG_SEEK : 0); + /* if audio is present, send pts of current audio frame, otherwise + * send current video frame pts */ + if (audio_trak) + xine_demux_control_newpts(this->stream, + audio_trak->frames[audio_trak->current_frame].pts, + audio_trak->frames[audio_trak->current_frame].pts ? BUF_FLAG_SEEK : 0); + else + xine_demux_control_newpts(this->stream, + video_trak->frames[video_trak->current_frame].pts, + video_trak->frames[video_trak->current_frame].pts ? BUF_FLAG_SEEK : 0); } - this->last_frame = this->current_frame; - this->current_frame++; + /* Decide the trak from which to dispatch a frame. Policy: Dispatch + * the frames in offset order as much as possible. If the pts difference + * between the current frames from the audio and video tables is too + * wide, make an exception. This exception deals with non-interleaved + * Quicktime files. */ + if (!audio_trak && !video_trak) { - /* check if all the samples have been sent */ - if (i >= this->qt->frame_count) { + /* something is really wrong if this case is reached */ this->status = DEMUX_FINISHED; return this->status; - } - /* check if we're only sending audio samples until the next keyframe */ - if ((this->waiting_for_keyframe) && - (this->qt->frames[i].type == MEDIA_VIDEO)) { - if (this->qt->frames[i].keyframe) { - this->waiting_for_keyframe = 0; - } else { - /* move on to the next sample */ + } else if (!audio_trak) { + + /* only video is present */ + dispatch_audio = 0; + if (video_trak->current_frame >= video_trak->frame_count) { + this->status = DEMUX_FINISHED; return this->status; } + + } else if (!video_trak) { + + /* only audio is present */ + dispatch_audio = 1; + if (audio_trak->current_frame >= audio_trak->frame_count) { + this->status = DEMUX_FINISHED; + return this->status; + } + + } else { + + /* both audio and video are present; start making some tough choices */ + + /* check the frame count limits */ + if ((audio_trak->current_frame >= audio_trak->frame_count) && + (video_trak->current_frame >= video_trak->frame_count)) { + + this->status = DEMUX_FINISHED; + return this->status; + + } else if (video_trak->current_frame >= video_trak->frame_count) { + + dispatch_audio = 1; + + } else if (audio_trak->current_frame >= audio_trak->frame_count) { + + dispatch_audio = 0; + + } else { + + /* at this point, it is certain that both traks still have frames + * yet to be dispatched */ + pts_diff = audio_trak->frames[audio_trak->current_frame].pts; + pts_diff -= video_trak->frames[video_trak->current_frame].pts; + + if (pts_diff > MAX_PTS_DIFF) { + /* if diff is +max_diff, audio is too far ahead of video */ + dispatch_audio = 0; + } else if (pts_diff < -MAX_PTS_DIFF) { + /* if diff is -max_diff, video is too far ahead of audio */ + dispatch_audio = 1; + } else if (audio_trak->frames[audio_trak->current_frame].offset < + video_trak->frames[video_trak->current_frame].offset) { + /* pts diff is not too wide, decide based on earlier offset */ + dispatch_audio = 1; + } else { + dispatch_audio = 0; + } + } } - if (this->qt->frames[i].type == MEDIA_VIDEO) { - remaining_sample_bytes = this->qt->frames[i].size; - this->input->seek(this->input, this->qt->frames[i].offset, + if (!dispatch_audio) { + i = video_trak->current_frame++; + remaining_sample_bytes = video_trak->frames[i].size; + this->input->seek(this->input, video_trak->frames[i].offset, SEEK_SET); - /* frame duration is the pts diff between this video frame and - * the next video frame (so search for the next video frame) */ - frame_duration = 0; - j = i; - while (++j < this->qt->frame_count) { - if (this->qt->frames[j].type == MEDIA_VIDEO) { - frame_duration = - this->qt->frames[j].pts - this->qt->frames[i].pts; - break; - } + if (i + 1 < video_trak->frame_count) { + /* frame duration is the pts diff between this video frame and + * the next video frame */ + frame_duration = video_trak->frames[i + 1].pts; + frame_duration -= video_trak->frames[i].pts; + } else { + /* give the last frame some fixed duration */ + frame_duration = 12000; } /* Due to the edit lists, some successive frames have the same pts @@ -1896,28 +1817,28 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { * to compensate. */ if (!frame_duration) { frame_duration = 1; - edit_list_compensation++; + video_trak->properties.video.edit_list_compensation++; } else { - frame_duration -= edit_list_compensation; - edit_list_compensation = 0; + frame_duration -= video_trak->properties.video.edit_list_compensation; + video_trak->properties.video.edit_list_compensation = 0; } this->stream->stream_info[XINE_STREAM_INFO_FRAME_DURATION] = frame_duration; - debug_video_demux(" qt: sending off frame %d (video) %d bytes, %lld pts, duration %d\n", + debug_video_demux(" qt: sending off video frame %d from offset 0x%llX, %d bytes, %lld pts\n", i, - this->qt->frames[i].size, - this->qt->frames[i].pts, - frame_duration); + video_trak->frames[i].offset, + video_trak->frames[i].size, + video_trak->frames[i].pts); while (remaining_sample_bytes) { buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); - buf->type = this->qt->video_type; - buf->extra_info->input_pos = this->qt->frames[i].offset - this->data_start; + buf->type = video_trak->properties.video.codec_buftype; + buf->extra_info->input_pos = video_trak->frames[i].offset - this->data_start; buf->extra_info->input_length = this->data_size; - buf->extra_info->input_time = this->qt->frames[i].pts / 90; - buf->pts = this->qt->frames[i].pts; + buf->extra_info->input_time = video_trak->frames[i].pts / 90; + buf->pts = video_trak->frames[i].pts; buf->decoder_flags |= BUF_FLAG_FRAMERATE; buf->decoder_info[0] = frame_duration; @@ -1935,7 +1856,7 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { break; } - if (this->qt->frames[i].keyframe) + if (video_trak->frames[i].keyframe) buf->decoder_flags |= BUF_FLAG_KEYFRAME; if (!remaining_sample_bytes) buf->decoder_flags |= BUF_FLAG_FRAME_END; @@ -1943,23 +1864,24 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { this->video_fifo->put(this->video_fifo, buf); } - } else if ((this->qt->frames[i].type == MEDIA_AUDIO) && - this->audio_fifo && this->qt->audio_type) { + } else { /* load an audio sample and packetize it */ - remaining_sample_bytes = this->qt->frames[i].size; - this->input->seek(this->input, this->qt->frames[i].offset, + i = audio_trak->current_frame++; + remaining_sample_bytes = audio_trak->frames[i].size; + this->input->seek(this->input, audio_trak->frames[i].offset, SEEK_SET); - debug_audio_demux(" qt: sending off frame %d (audio) %d bytes, %lld pts\n", + debug_audio_demux(" qt: sending off audio frame %d from offset 0x%llX, %d bytes, %lld pts\n", i, - this->qt->frames[i].size, - this->qt->frames[i].pts); + audio_trak->frames[i].offset, + audio_trak->frames[i].size, + audio_trak->frames[i].pts); first_buf = 1; while (remaining_sample_bytes) { buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo); - buf->type = this->qt->audio_type; - buf->extra_info->input_pos = this->qt->frames[i].offset - this->data_start; + buf->type = audio_trak->properties.audio.codec_buftype; + buf->extra_info->input_pos = audio_trak->frames[i].offset - this->data_start; buf->extra_info->input_length = this->data_size; /* The audio chunk is often broken up into multiple 8K buffers when * it is sent to the audio decoder. Only attach the proper timestamp @@ -1970,16 +1892,16 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { if ((buf->type == BUF_AUDIO_LPCM_BE) || (buf->type == BUF_AUDIO_LPCM_LE)) { if (first_buf) { - buf->extra_info->input_time = this->qt->frames[i].pts / 90; - buf->pts = this->qt->frames[i].pts; + buf->extra_info->input_time = audio_trak->frames[i].pts / 90; + buf->pts = audio_trak->frames[i].pts; first_buf = 0; } else { buf->extra_info->input_time = 0; buf->pts = 0; } } else { - buf->extra_info->input_time = this->qt->frames[i].pts / 90; - buf->pts = this->qt->frames[i].pts; + buf->extra_info->input_time = audio_trak->frames[i].pts / 90; + buf->pts = audio_trak->frames[i].pts; } if (remaining_sample_bytes > buf->max_size) @@ -1997,9 +1919,9 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { /* Special case alert: If this is signed, 8-bit data, transform * the data to unsigned. */ - if ((this->qt->audio_bits == 8) && - ((this->qt->audio_codec == TWOS_FOURCC) || - (this->qt->audio_codec == SOWT_FOURCC))) + if ((audio_trak->properties.audio.bits == 8) && + ((audio_trak->properties.audio.codec_fourcc == TWOS_FOURCC) || + (audio_trak->properties.audio.codec_fourcc == SOWT_FOURCC))) for (j = 0; j < buf->size; j++) buf->content[j] += 0x80; @@ -2010,6 +1932,7 @@ static int demux_qt_send_chunk(demux_plugin_t *this_gen) { this->audio_fifo->put(this->audio_fifo, buf); } } + return this->status; } @@ -2017,54 +1940,115 @@ static void demux_qt_send_headers(demux_plugin_t *this_gen) { demux_qt_t *this = (demux_qt_t *) this_gen; buf_element_t *buf; + qt_trak *video_trak = NULL; + qt_trak *audio_trak = NULL; + + /* for deciding data start and data size */ + int64_t first_video_offset = -1; + int64_t last_video_offset = -1; + int64_t first_audio_offset = -1; + int64_t last_audio_offset = -1; this->video_fifo = this->stream->video_fifo; this->audio_fifo = this->stream->audio_fifo; this->status = DEMUX_OK; - this->data_start = this->qt->frames[0].offset; - this->data_size = - this->qt->frames[this->qt->frame_count - 1].offset + - this->qt->frames[this->qt->frame_count - 1].size - - this->data_start; + /* figure out where the data begins and ends */ + if (this->qt->video_trak != -1) { + video_trak = &this->qt->traks[this->qt->video_trak]; + first_video_offset = video_trak->frames[0].offset; + last_video_offset = video_trak->frames[video_trak->frame_count - 1].size + + video_trak->frames[video_trak->frame_count - 1].offset; + } + if (this->qt->audio_trak != -1) { + audio_trak = &this->qt->traks[this->qt->audio_trak]; + first_audio_offset = audio_trak->frames[0].offset; + last_audio_offset = audio_trak->frames[audio_trak->frame_count - 1].size + + audio_trak->frames[audio_trak->frame_count - 1].offset; + } + + if (first_video_offset < first_audio_offset) + this->data_start = first_video_offset; + else + this->data_start = first_audio_offset; + + if (last_video_offset > last_audio_offset) + this->data_size = last_video_offset - this->data_size; + else + this->data_size = last_audio_offset - this->data_size; + + /* sort out the A/V information */ + if (this->qt->video_trak != -1) { + + this->bih.biSize = sizeof(this->bih); + this->bih.biWidth = video_trak->properties.video.width; + this->bih.biHeight = video_trak->properties.video.height; + this->bih.biBitCount = video_trak->properties.video.depth; + + this->bih.biCompression = video_trak->properties.video.codec_fourcc; + video_trak->properties.video.codec_buftype = + fourcc_to_buf_video(this->bih.biCompression); + + /* hack: workaround a fourcc clash! 'mpg4' is used by MS and Sorenson + * mpeg4 codecs (they are not compatible). + */ + if( video_trak->properties.video.codec_buftype == BUF_VIDEO_MSMPEG4_V1 ) + video_trak->properties.video.codec_buftype = BUF_VIDEO_MPEG4; + + if( !video_trak->properties.video.codec_buftype && + video_trak->properties.video.codec_fourcc ) + video_trak->properties.video.codec_buftype = BUF_VIDEO_UNKNOWN; + + this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = 1; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] = + this->bih.biWidth; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] = + this->bih.biHeight; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_FOURCC] = + video_trak->properties.video.codec_fourcc; - this->bih.biSize = sizeof(this->bih); - this->bih.biWidth = this->qt->video_width; - this->bih.biHeight = this->qt->video_height; - this->bih.biBitCount = this->qt->video_depth; + } else { - this->bih.biCompression = this->qt->video_codec; - this->qt->video_type = fourcc_to_buf_video(this->bih.biCompression); + memset(&this->bih, 0, sizeof(this->bih)); + this->bih.biSize = sizeof(this->bih); + this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = 0; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] = 0; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] = 0; + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_FOURCC] = 0; - /* hack: workaround a fourcc clash! 'mpg4' is used by MS and Sorenson - * mpeg4 codecs (they are not compatible). - */ - if( this->qt->video_type == BUF_VIDEO_MSMPEG4_V1 ) - this->qt->video_type = BUF_VIDEO_MPEG4; - - if( !this->qt->video_type && this->qt->video_codec ) - this->qt->video_type = BUF_VIDEO_UNKNOWN; + } - this->qt->audio_type = formattag_to_buf_audio(this->qt->audio_codec); + if (this->qt->audio_trak != -1) { - if( !this->qt->audio_type && this->qt->audio_codec ) - this->qt->audio_type = BUF_AUDIO_UNKNOWN; - - /* load stream information */ - this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = - (this->qt->video_type) ? 1 : 0; - this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = - (this->qt->audio_type) ? 1 : 0; - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] = this->bih.biWidth; - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] = this->bih.biHeight; - this->stream->stream_info[XINE_STREAM_INFO_AUDIO_CHANNELS] = - this->qt->audio_channels; - this->stream->stream_info[XINE_STREAM_INFO_AUDIO_SAMPLERATE] = - this->qt->audio_sample_rate; - this->stream->stream_info[XINE_STREAM_INFO_AUDIO_BITS] = - this->qt->audio_bits; + audio_trak->properties.audio.codec_buftype = + formattag_to_buf_audio(audio_trak->properties.audio.codec_fourcc); + if( !audio_trak->properties.audio.codec_buftype && + audio_trak->properties.audio.codec_fourcc ) + audio_trak->properties.audio.codec_buftype = BUF_AUDIO_UNKNOWN; + + this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = 1; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_CHANNELS] = + audio_trak->properties.audio.channels; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_SAMPLERATE] = + audio_trak->properties.audio.sample_rate; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_BITS] = + audio_trak->properties.audio.bits; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_FOURCC] = + audio_trak->properties.audio.codec_fourcc; + + } else { + + this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = 0; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_CHANNELS] = 0; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_SAMPLERATE] = 0; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_BITS] = 0; + this->stream->stream_info[XINE_STREAM_INFO_AUDIO_FOURCC] = 0; + + } + + /* copy over the meta information like artist and title */ if (this->qt->copyright) this->stream->meta_info[XINE_META_INFO_ARTIST] = strdup(this->qt->copyright); @@ -2075,76 +2059,78 @@ static void demux_qt_send_headers(demux_plugin_t *this_gen) { this->stream->meta_info[XINE_META_INFO_COMMENT] = strdup(this->qt->comment); - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_FOURCC] = - this->qt->video_codec; - this->stream->stream_info[XINE_STREAM_INFO_AUDIO_FOURCC] = - this->qt->audio_codec; - /* send start buffers */ xine_demux_control_start(this->stream); /* send init info to decoders */ - buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); - buf->decoder_flags = BUF_FLAG_HEADER; - buf->decoder_info[0] = 0; - buf->decoder_info[1] = 3000; /* initial video_step */ - memcpy(buf->content, &this->bih, sizeof(this->bih)); - buf->size = sizeof(this->bih); - buf->type = this->qt->video_type; - this->video_fifo->put (this->video_fifo, buf); - - /* send header info to decoder. some mpeg4 streams need this */ - if( this->qt->video_decoder_config ) { + if (video_trak && + (video_trak->properties.video.codec_buftype)) { buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); - buf->type = this->qt->video_type; - buf->size = this->qt->video_decoder_config_len; - buf->content = this->qt->video_decoder_config; + buf->decoder_flags = BUF_FLAG_HEADER; + buf->decoder_info[0] = 0; + /* initial video step; not necessary since each QT frame has its own + * duration, but set it non-zero as a matter of custom */ + buf->decoder_info[1] = 3000; + memcpy(buf->content, &this->bih, sizeof(this->bih)); + buf->size = sizeof(this->bih); + buf->type = video_trak->properties.video.codec_buftype; this->video_fifo->put (this->video_fifo, buf); - } + + /* send header info to decoder. some mpeg4 streams need this */ + if( video_trak->decoder_config ) { + buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); + buf->type = video_trak->properties.video.codec_buftype; + buf->size = video_trak->decoder_config_len; + buf->content = video_trak->decoder_config; + this->video_fifo->put (this->video_fifo, buf); + } + + /* send off the palette, if there is one */ + if (video_trak->properties.video.palette_count) { + buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); + buf->decoder_flags = BUF_FLAG_SPECIAL; + buf->decoder_info[1] = BUF_SPECIAL_PALETTE; + buf->decoder_info[2] = video_trak->properties.video.palette_count; + buf->decoder_info_ptr[2] = &video_trak->properties.video.palette; + buf->size = 0; + buf->type = video_trak->properties.video.codec_buftype; + this->video_fifo->put (this->video_fifo, buf); + } - /* send off the palette, if there is one */ - if (this->qt->palette_count) { + /* send stsd to the decoder */ buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); buf->decoder_flags = BUF_FLAG_SPECIAL; - buf->decoder_info[1] = BUF_SPECIAL_PALETTE; - buf->decoder_info[2] = this->qt->palette_count; - buf->decoder_info_ptr[2] = &this->qt->palette; + buf->decoder_info[1] = BUF_SPECIAL_STSD_ATOM; + buf->decoder_info[2] = video_trak->stsd_size; + buf->decoder_info_ptr[2] = video_trak->stsd; buf->size = 0; - buf->type = this->qt->video_type; + buf->type = video_trak->properties.video.codec_buftype; this->video_fifo->put (this->video_fifo, buf); } - /* send stsd to the decoder */ - buf = this->video_fifo->buffer_pool_alloc (this->video_fifo); - buf->decoder_flags = BUF_FLAG_SPECIAL; - buf->decoder_info[1] = BUF_SPECIAL_STSD_ATOM; - buf->decoder_info[2] = this->qt->video_stsd_size; - buf->decoder_info_ptr[2] = this->qt->video_stsd; - buf->size = 0; - buf->type = this->qt->video_type; - this->video_fifo->put (this->video_fifo, buf); - + if ((this->qt->audio_trak != -1) && + (audio_trak->properties.audio.codec_buftype) && + this->audio_fifo) { - if (this->audio_fifo && this->qt->audio_type) { buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo); - buf->type = this->qt->audio_type; + buf->type = audio_trak->properties.audio.codec_buftype; buf->decoder_flags = BUF_FLAG_HEADER; buf->decoder_info[0] = 0; - buf->decoder_info[1] = this->qt->audio_sample_rate; - buf->decoder_info[2] = this->qt->audio_bits; - buf->decoder_info[3] = this->qt->audio_channels; - buf->content = (void *)&this->qt->wave; - buf->size = sizeof(this->qt->wave); + buf->decoder_info[1] = audio_trak->properties.audio.sample_rate; + buf->decoder_info[2] = audio_trak->properties.audio.bits; + buf->decoder_info[3] = audio_trak->properties.audio.channels; + buf->content = (void *)&audio_trak->properties.audio.wave; + buf->size = sizeof(audio_trak->properties.audio.wave); this->audio_fifo->put (this->audio_fifo, buf); - if( this->qt->audio_decoder_config ) { + if( audio_trak->decoder_config ) { buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo); - buf->type = this->qt->audio_type; + buf->type = audio_trak->properties.audio.codec_buftype; buf->size = 0; buf->decoder_flags = BUF_FLAG_SPECIAL; buf->decoder_info[1] = BUF_SPECIAL_DECODER_CONFIG; - buf->decoder_info[2] = this->qt->audio_decoder_config_len; - buf->decoder_info_ptr[2] = this->qt->audio_decoder_config; + buf->decoder_info[2] = audio_trak->decoder_config_len; + buf->decoder_info_ptr[2] = audio_trak->decoder_config; this->audio_fifo->put (this->audio_fifo, buf); } @@ -2152,49 +2138,44 @@ static void demux_qt_send_headers(demux_plugin_t *this_gen) { buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo); buf->decoder_flags = BUF_FLAG_SPECIAL; buf->decoder_info[1] = BUF_SPECIAL_STSD_ATOM; - buf->decoder_info[2] = this->qt->audio_stsd_size; - buf->decoder_info_ptr[2] = this->qt->audio_stsd; + buf->decoder_info[2] = audio_trak->stsd_size; + buf->decoder_info_ptr[2] = audio_trak->stsd; buf->size = 0; - buf->type = this->qt->audio_type; + buf->type = audio_trak->properties.audio.codec_buftype; this->audio_fifo->put (this->audio_fifo, buf); } } -static int demux_qt_seek (demux_plugin_t *this_gen, - off_t start_pos, int start_time) { - demux_qt_t *this = (demux_qt_t *) this_gen; +/* support function that performs a binary seek on a trak; returns the + * demux status */ +static int binary_seek(qt_trak *trak, off_t start_pos, int start_time) { int best_index; int left, middle, right; int found; - int64_t keyframe_pts; - - this->waiting_for_keyframe = 0; /* perform a binary search on the sample table, testing the offset - * boundaries first */ + * boundaries first; offset request has precedent over time request */ if (start_pos) { - if (start_pos <= this->qt->frames[0].offset) + if (start_pos <= trak->frames[0].offset) best_index = 0; - else if (start_pos >= this->qt->frames[this->qt->frame_count - 1].offset) { - this->status = DEMUX_FINISHED; - return this->status; - } else { + else if (start_pos >= trak->frames[trak->frame_count - 1].offset) + return DEMUX_FINISHED; + else { left = 0; - right = this->qt->frame_count - 1; + right = trak->frame_count - 1; found = 0; while (!found) { - middle = (left + right) / 2; - if ((start_pos >= this->qt->frames[middle].offset) && - (start_pos <= this->qt->frames[middle].offset + - this->qt->frames[middle].size)) { - found = 1; - } else if (start_pos < this->qt->frames[middle].offset) { - right = middle; - } else { - left = middle; + middle = (left + right + 1) / 2; + if ((start_pos >= trak->frames[middle].offset) && + (start_pos < trak->frames[middle + 1].offset)) { + found = 1; + } else if (start_pos < trak->frames[middle].offset) { + right = middle - 1; + } else { + left = middle; } } @@ -2203,17 +2184,16 @@ static int demux_qt_seek (demux_plugin_t *this_gen, } else { int64_t pts = 90000 * start_time; - if (pts <= this->qt->frames[0].pts) + if (pts <= trak->frames[0].pts) best_index = 0; - else if (pts >= this->qt->frames[this->qt->frame_count - 1].pts) { - this->status = DEMUX_FINISHED; - return this->status; - } else { + else if (pts >= trak->frames[trak->frame_count - 1].pts) + return DEMUX_FINISHED; + else { left = 0; - right = this->qt->frame_count - 1; + right = trak->frame_count - 1; do { middle = (left + right + 1) / 2; - if (pts < this->qt->frames[middle].pts) { + if (pts < trak->frames[middle].pts) { right = (middle - 1); } else { left = middle; @@ -2224,36 +2204,62 @@ static int demux_qt_seek (demux_plugin_t *this_gen, } } - /* search back in the table for the nearest keyframe */ - while (best_index) { - if (this->qt->frames[best_index].keyframe) { - break; - } - best_index--; + trak->current_frame = best_index; + return DEMUX_OK; +} + +static int demux_qt_seek (demux_plugin_t *this_gen, + off_t start_pos, int start_time) { + + demux_qt_t *this = (demux_qt_t *) this_gen; + qt_trak *video_trak = NULL; + qt_trak *audio_trak = NULL; + + int64_t keyframe_pts; + + /* if there is a video trak, position it as close as possible to the + * requested position */ + if (this->qt->video_trak != -1) { + video_trak = &this->qt->traks[this->qt->video_trak]; + this->status = binary_seek(video_trak, start_pos, start_time); + if (this->status != DEMUX_OK) + return this->status; } + if (this->qt->audio_trak != -1) { + audio_trak = &this->qt->traks[this->qt->audio_trak]; + this->status = binary_seek(audio_trak, start_pos, start_time); + if (this->status != DEMUX_OK) + return this->status; + } + + /* search back in the video trak for the nearest keyframe */ + if (video_trak) + while (video_trak->current_frame) { + if (video_trak->frames[video_trak->current_frame].keyframe) { + break; + } + video_trak->current_frame--; + } + /* not done yet; now that the nearest keyframe has been found, seek * back to the first audio frame that has a pts less than or equal to - * that of the keyframe */ - this->waiting_for_keyframe = 1; - keyframe_pts = this->qt->frames[best_index].pts; - while (best_index) { - if ((this->qt->frames[best_index].type == MEDIA_AUDIO) && - (this->qt->frames[best_index].pts < keyframe_pts)) { - break; + * that of the keyframe; do not go through with this process there is + * no video trak */ + if (audio_trak && video_trak) { + keyframe_pts = video_trak->frames[video_trak->current_frame].pts; + while (audio_trak->current_frame) { + if (audio_trak->frames[audio_trak->current_frame].pts < keyframe_pts) { + break; + } + audio_trak->current_frame--; } - best_index--; } - this->current_frame = best_index; + this->qt->seek_flag = 1; this->status = DEMUX_OK; + xine_demux_flush_engine(this->stream); - if( !this->stream->demux_thread_running ) { - this->last_frame = 0; - } else { - xine_demux_flush_engine(this->stream); - } - return this->status; } |