C++ (Cpp) quicktime_samples_to_bytes Examples

Example #1

File: quicktime.c Project: knutj/cinelerra

long quicktime_read_audio(quicktime_t *file,
	char *audio_buffer, long samples, int track)
{
	quicktime_audio_map_t *track_map = &file->atracks[track];
	quicktime_trak_t *trak = track_map->track;
	int64_t position, chunk, chunk_sample;
	long ret, bytes, chunk_offset, chunk_len;
	int result = 0;

	position = file->atracks[track].current_position;
	quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, position);
	ret = 0;

	while( samples > 0 ) {
		int64_t offset = quicktime_sample_to_offset(file, trak, position);
		quicktime_set_position(file, offset);
		chunk_offset = position - chunk_sample;
		chunk_len = quicktime_chunk_samples(trak, chunk) - chunk_offset;
		if( chunk_len > samples ) chunk_len = samples;
		else ++chunk;
		chunk_sample = (position += chunk_len);
		bytes = quicktime_samples_to_bytes(trak, chunk_len);
		result = !quicktime_read_data(file, &audio_buffer[ret], bytes);
		if( result ) break;
		ret += bytes;
		samples -= chunk_len;
	}
//printf("quicktime_read_audio 5\n");

	track_map->current_position = position;
	track_map->current_chunk = chunk;
	return !result ? ret : 0;
}

Example #2

File: quicktime.c Project: beequ7et/cinelerra-cv

long quicktime_read_audio(quicktime_t *file, 
	char *audio_buffer, 
	long samples, 
	int track)
{
	int64_t chunk_sample, chunk;
	int result = 0, track_num;
	quicktime_trak_t *trak = file->atracks[track].track;
	int64_t fragment_len, chunk_end;
	int64_t start_position = file->atracks[track].current_position;
	int64_t position = file->atracks[track].current_position;
	int64_t start = position, end = position + samples;
	int64_t bytes, total_bytes = 0;
	int64_t buffer_offset;

//printf("quicktime_read_audio 1\n");
	quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, position);
	buffer_offset = 0;

	while(position < end && !result)
	{
		quicktime_set_audio_position(file, position, track);
		fragment_len = quicktime_chunk_samples(trak, chunk);
		chunk_end = chunk_sample + fragment_len;
		fragment_len -= position - chunk_sample;
		if(position + fragment_len > chunk_end) fragment_len = chunk_end - position;
		if(position + fragment_len > end) fragment_len = end - position;

		bytes = quicktime_samples_to_bytes(trak, fragment_len);
/*
 * printf("quicktime_read_audio 2 %llx %llx %d\n", 
 * quicktime_position(file), 
 * quicktime_position(file) + bytes, 
 * samples);
 * sleep(1);
 */
		result = !quicktime_read_data(file, &audio_buffer[buffer_offset], bytes);
//printf("quicktime_read_audio 4\n");

		total_bytes += bytes;
		position += fragment_len;
		chunk_sample = position;
		buffer_offset += bytes;
		chunk++;
	}
//printf("quicktime_read_audio 5\n");

// Create illusion of track being advanced only by samples
	file->atracks[track].current_position = start_position + samples;
	if(result) return 0;
	return total_bytes;
}

Example #3

File: trak.c Project: PhymurByrd/mp4

long quicktime_sample_range_size(quicktime_trak_t *trak, long chunk_sample, long sample)
{
    quicktime_stsz_table_t *table = trak->mdia.minf.stbl.stsz.table;
    long i, total;

    if(trak->mdia.minf.stbl.stsz.sample_size)
    {
        /* assume audio */
        return quicktime_samples_to_bytes(trak, sample - chunk_sample);
    }
    else
    {
        /* probably video */
        for(i = chunk_sample, total = 0; i < sample; i++)
        {
            total += trak->mdia.minf.stbl.stsz.table[i].size;
        }
    }
    return total;
}

Example #4

File: quicktime.c Project: HunterChen/mpeg4ip

long quicktime_read_audio(quicktime_t *file, char *audio_buffer, long samples, int track)
{
	long chunk_sample, chunk;
	int result = 1, track_num;
	quicktime_trak_t *trak = file->atracks[track].track;
	long fragment_len, chunk_end;
	long position = file->atracks[track].current_position;
	long start = position, end = position + samples;
	long bytes, total_bytes = 0;
	long buffer_offset;

	quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, position);
	buffer_offset = 0;

	while(position < end && result)
	{
		quicktime_set_audio_position(file, position, track);
		fragment_len = quicktime_chunk_samples(trak, chunk);
		chunk_end = chunk_sample + fragment_len;
		fragment_len -= position - chunk_sample;
		if(position + fragment_len > chunk_end) fragment_len = chunk_end - position;
		if(position + fragment_len > end) fragment_len = end - position;

		bytes = quicktime_samples_to_bytes(trak, fragment_len);
		result = quicktime_read_data(file, &audio_buffer[buffer_offset], bytes);

		total_bytes += bytes;
		position += fragment_len;
		chunk_sample = position;
		buffer_offset += bytes;
		chunk++;
	}

	file->atracks[track].current_position = position;
	if(!result) return 0;
	return total_bytes;
}