예제 #1
0
파일: trak.c 프로젝트: PhymurByrd/mp4
int quicktime_update_tables(quicktime_t *file, 
                            quicktime_trak_t *trak, 
                            long offset, 
                            long chunk, 
                            long sample, 
                            long samples, 
                            long sample_size,
                            long sample_duration,
                            u_char isSyncSample,
                            long renderingOffset)
{
    if (offset + sample_size > file->mdat.size) {
        file->mdat.size = offset + sample_size;
    }
    quicktime_update_stco(&(trak->mdia.minf.stbl.stco), chunk, offset);
    if (sample_size) {
        quicktime_update_stsz(&(trak->mdia.minf.stbl.stsz), sample, sample_size);
    }
    quicktime_update_stsc(&(trak->mdia.minf.stbl.stsc), chunk, samples);
    if (sample_duration) {
        quicktime_update_stts(&(trak->mdia.minf.stbl.stts), sample_duration);
    }
    if (isSyncSample) {
        quicktime_update_stss(&(trak->mdia.minf.stbl.stss), sample);
    }
    quicktime_update_ctts(&(trak->mdia.minf.stbl.ctts), renderingOffset);
    return 0;
}
예제 #2
0
void quicktime_import_avi(quicktime_t *file)
{
	int i, j, k;
	quicktime_riff_t *first_riff = file->riff[0];
	quicktime_idx1_t *idx1 = &first_riff->idx1;
	quicktime_hdrl_t *hdrl = &first_riff->hdrl;



/* Determine whether to use idx1 or indx indexes for offsets. */
/* idx1 must always be used for keyframes but it also must be */
/* ignored for offsets if indx exists. */


//printf("quicktime_import_avi 1\n");
/* Convert idx1 to keyframes and load offsets and sizes */


// This is a check from mplayer that gives us the right strategy
// for calculating real offset.
// but first the 
	int index_format = 0;
	
	if(idx1->table_size > 1)
	{
//		if((idx1->table[0].offset < first_riff->movi.atom.start ||
//        		idx1->table[1].offset < first_riff->movi.atom.start) && 
		if((idx1->table[0].offset < first_riff->movi.atom.start + 4 ||
        		idx1->table[1].offset < first_riff->movi.atom.start + 4) &&
        	!file->is_odml)
        	index_format = 1;
    	else 
        	index_format = 0;
	}

	for(i = 0; i < idx1->table_size; i++)
	{
		quicktime_idx1table_t *idx1table = idx1->table + i;
		char *tag = idx1table->tag;
		int track_number = (tag[0] - '0') * 10 + (tag[1] - '0');
		if(track_number < file->moov.total_tracks)
		{
			quicktime_trak_t *trak = file->moov.trak[track_number];
			quicktime_strl_t *strl = first_riff->hdrl.strl[track_number];
			int is_audio = trak->mdia.minf.is_audio;
			int is_video = trak->mdia.minf.is_video;


/* Chunk offset */
			quicktime_stco_t *stco = &trak->mdia.minf.stbl.stco;
/* Sample size */
			quicktime_stsz_t *stsz = &trak->mdia.minf.stbl.stsz;
/* Samples per chunk */
			quicktime_stsc_t *stsc = &trak->mdia.minf.stbl.stsc;
/* Sample description */
			quicktime_stsd_t *stsd = &trak->mdia.minf.stbl.stsd;




/* Enter the offset and size no matter what so the sample counts */
/* can be used to set keyframes */
			if (index_format == 1)
				quicktime_update_stco(stco, 
						stco->total_entries + 1, 
						idx1table->offset + first_riff->movi.atom.start);
			else	
				quicktime_update_stco(stco, 
						stco->total_entries + 1, 
						idx1table->offset);

			if(is_video)
			{
/* Just get the keyframe flag.  don't call quicktime_insert_keyframe because */
/* that updates idx1 and we don't have a track map. */
				int is_keyframe = (idx1table->flags & AVI_KEYFRAME) == AVI_KEYFRAME;
				if(is_keyframe)
				{
					quicktime_stss_t *stss = &trak->mdia.minf.stbl.stss;
/* This is done before the image size table so this value is right */
					int frame = stsz->total_entries;

/* Expand table */
					if(stss->entries_allocated <= stss->total_entries)
					{
						stss->entries_allocated *= 2;
						stss->table = realloc(stss->table, 
							sizeof(quicktime_stss_table_t) * stss->entries_allocated);
					}
					stss->table[stss->total_entries++].sample = frame;
				}

/* Set image size */
				quicktime_update_stsz(stsz, 
							stsz->total_entries, 
							idx1table->size);
			}
			else
			if(is_audio)
			{
				strl->total_bytes += idx1table->size;
/* Set samples per chunk if PCM */
				if(stsd->table[0].sample_size > 0)
				{
					quicktime_update_stsc(stsc, 
						stsc->total_entries + 1, 
						idx1table->size * 
							8 / 
							stsd->table[0].sample_size / 
							stsd->table[0].channels);
				}
			}
		}
	}

//printf("quicktime_import_avi 10\n");


/* Convert super indexes into Quicktime indexes. */
/* Append to existing entries if idx1 exists. */
/* No keyframes here. */
	for(i = 0; i < file->moov.total_tracks; i++)
	{
		quicktime_strl_t *strl = first_riff->hdrl.strl[i];

		if(strl->have_indx)
		{
			quicktime_indx_t *indx = &strl->indx;
			quicktime_trak_t *trak = file->moov.trak[i];
			quicktime_stco_t *stco = &trak->mdia.minf.stbl.stco;
			quicktime_stsz_t *stsz = &trak->mdia.minf.stbl.stsz;
			quicktime_stsc_t *stsc = &trak->mdia.minf.stbl.stsc;
			quicktime_stsd_t *stsd = &trak->mdia.minf.stbl.stsd;
/* Get existing chunk count from the idx1 */
			int existing_chunks = stco->total_entries;

/* Read each indx entry */
			for(j = 0; j < indx->table_size; j++)
			{
				quicktime_indxtable_t *indx_table = &indx->table[j];
				quicktime_ix_t *ix = indx_table->ix;

				for(k = 0; k < ix->table_size; k++)
				{
/* Copy from existing chunk count to end of ix table */
					if(existing_chunks <= 0)
					{
						quicktime_ixtable_t *ixtable = &ix->table[k];

/* Do the same things that idx1 did to the chunk tables */
/* Subtract the super indexes by size of the header.  McRoweSoft seems to */
/* want the header before the ix offset but after the idx1 offset. */
						quicktime_update_stco(stco, 
							stco->total_entries + 1, 
							ixtable->relative_offset + ix->base_offset - 8);
						if(strl->is_video)
						{
							quicktime_update_stsz(stsz, 
								stsz->total_entries, 
								ixtable->size);
						}
						else
						if(strl->is_audio)
						{
							strl->total_bytes += ixtable->size;
							if(stsd->table[0].sample_size > 0)
							{
								quicktime_update_stsc(stsc, 
									stsc->total_entries + 1, 
									ixtable->size * 
									8 / 
									stsd->table[0].sample_size / 
									stsd->table[0].channels);
							}
						}
					}
					else
						existing_chunks--;
				}
			}
		}
	}


//printf("quicktime_import_avi 20\n");




/* Set total samples, time to sample, for audio */
	for(i = 0; i < file->moov.total_tracks; i++)
	{
		quicktime_trak_t *trak = file->moov.trak[i];
		quicktime_stsz_t *stsz = &trak->mdia.minf.stbl.stsz;
		quicktime_stsc_t *stsc = &trak->mdia.minf.stbl.stsc;
		quicktime_stco_t *stco = &trak->mdia.minf.stbl.stco;
		quicktime_stts_t *stts = &trak->mdia.minf.stbl.stts;
		quicktime_stsd_t *stsd = &trak->mdia.minf.stbl.stsd;

		if(trak->mdia.minf.is_audio)
		{
 			quicktime_stsc_table_t *stsc_table = stsc->table;
			quicktime_strl_t *strl = first_riff->hdrl.strl[i];
			int64_t total_entries = stsc->total_entries;
			int64_t chunk = stco->total_entries;
			int64_t sample = 0;

//printf("quicktime_import_avi %lld %lld %lld\n", 
//strl->total_bytes, strl->bytes_per_second, (int)stsd->table[0].sample_rate);
// Derive stsc from bitrate for some MP3 files
			if(!total_entries)
			{
				quicktime_update_stsc(stsc, 
					++total_entries, 
					strl->total_bytes / 
						strl->bytes_per_second * 
						(int)stsd->table[0].sample_rate);
			}


// Derive total samples from samples per chunk table
			if(chunk > 0)
			{
				sample = quicktime_sample_of_chunk(trak, chunk) + 
					stsc_table[total_entries - 1].samples;
			}

			stsz->sample_size = 1;
			stsz->total_entries = sample;
			stts->table[0].sample_count = sample;
		}
		else
		if(trak->mdia.minf.is_video)
		{
			stsc->total_entries = 1;
/* stts has 1 allocation by default */
			stts->table[0].sample_count = stco->total_entries;
		}
	}

//printf("quicktime_import_avi 30\n");

}