libmpeg3.c

MPEG-4编解码的实现(包括MPEG4视音频编解码)

	{
/* Video only */
//printf("libmpeg3 5\n");
		file->is_video_stream = 1;
	}
	else
	if(((bits & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE)
	{
/* AC3 Audio only */
//printf("libmpeg3 6\n");
		file->is_audio_stream = 1;
	}
	else
	{
//printf("libmpeg3 7\n");
		mpeg3_delete(file);
		fprintf(stderr, "mpeg3_open: not an MPEG 2 stream\n");
		return 0;
	}

//printf("mpeg3_open 2 %p %d %d %d %d\n", 
//	old_file, file->is_transport_stream, file->is_program_stream, file->is_video_stream, file->is_audio_stream);













// Configure packet size
	if(file->is_transport_stream)
		file->packet_size = MPEG3_TS_PACKET_SIZE;
	else
	if(file->is_program_stream)
		file->packet_size = 0;
	else
	if(file->is_audio_stream)
		file->packet_size = MPEG3_DVD_PACKET_SIZE;
	else
	if(file->is_video_stream)
		file->packet_size = MPEG3_DVD_PACKET_SIZE;













//printf("mpeg3_open 1\n");

/* Create titles */
/* Copy timecodes from an old demuxer */
	if(old_file && mpeg3_get_demuxer(old_file))
	{
		mpeg3demux_copy_titles(file->demuxer, mpeg3_get_demuxer(old_file));
		file->is_transport_stream = old_file->is_transport_stream;
		file->is_program_stream = old_file->is_program_stream;
	}
	else
/* Start from scratch */
	if(!file->demuxer->total_titles)
	{
		mpeg3demux_create_title(file->demuxer, 0, 0);
	}



//printf("mpeg3_open 2\n");











/* Generate tracks */
	if(file->is_transport_stream || file->is_program_stream)
	{
/* Create video tracks */
/* Video must be created before audio because audio uses the video timecode */
/* to get its length. */
		for(i = 0; i < MPEG3_MAX_STREAMS; i++)
		{
			if(file->demuxer->vstream_table[i])
			{
				file->vtrack[file->total_vstreams] = 
					mpeg3_new_vtrack(file, 
						i, 
						file->demuxer, 
						file->total_vstreams);
				if(file->vtrack[file->total_vstreams]) 
					file->total_vstreams++;

//printf("libmpeg3 %d %d %p %d\n", i, file->demuxer->vstream_table[i], file->vtrack[file->total_vstreams], file->total_vstreams);
			}
		}

/* Create audio tracks */
		for(i = 0; i < MPEG3_MAX_STREAMS; i++)
		{
			if(file->demuxer->astream_table[i])
			{
				file->atrack[file->total_astreams] = mpeg3_new_atrack(file, 
					i, 
					file->demuxer->astream_table[i], 
					file->demuxer,
					file->total_astreams);
				if(file->atrack[file->total_astreams]) file->total_astreams++;
			}
		}
	}
	else
	if(file->is_video_stream)
	{
/* Create video tracks */
//printf("mpeg3_open 3\n");
		file->vtrack[0] = mpeg3_new_vtrack(file, 
			-1, 
			file->demuxer, 
			0);
//printf("mpeg3_open 4\n");
		if(file->vtrack[0]) file->total_vstreams++;
	}
	else
	if(file->is_audio_stream)
	{
/* Create audio tracks */

//printf("mpeg3_open 3\n");
		file->atrack[0] = mpeg3_new_atrack(file, 
			-1, 
			AUDIO_UNKNOWN, 
			file->demuxer,
			0);
//printf("mpeg3_open 3\n");
		if(file->atrack[0]) file->total_astreams++;
	}

//printf("mpeg3_open 5\n");



	mpeg3io_close_file(file->fs);
	return file;
}

mpeg3_t* mpeg3_open(const char *path)
{
	return mpeg3_open_copy(path, 0);
}

int mpeg3_close(mpeg3_t *file)
{
/* File is closed in the same procedure it is opened in. */
	mpeg3_delete(file);
	return 0;
}


int mpeg3_has_audio(mpeg3_t *file)
{
	return file->total_astreams > 0;
}

int mpeg3_total_astreams(mpeg3_t *file)
{
	return file->total_astreams;
}

int mpeg3_audio_channels(mpeg3_t *file,
		int stream)
{
	if(file->total_astreams)
		return file->atrack[stream]->channels;
	return -1;
}

int mpeg3_sample_rate(mpeg3_t *file,
		int stream)
{
	if(file->total_astreams)
		return file->atrack[stream]->sample_rate;
	return -1;
}

int mpeg3_audio_samples_per_frame(mpeg3_t *file,
		int stream)
{
	if(file->total_astreams)
		return file->atrack[stream]->samples_per_frame;
	return -1;
}

uint32_t mpeg3_audio_get_number_of_frames (mpeg3_t *file, 
					   int stream)
{
  if (file->total_astreams) 
    return file->atrack[stream]->total_frames;
  return -1;
}

char* mpeg3_audio_format(mpeg3_t *file, int stream)
{
	if(stream < file->total_astreams)
	{
		switch(file->atrack[stream]->format)
		{
			case AUDIO_UNKNOWN: return "Unknown"; break;
			case AUDIO_MPEG:    return "MPEG"; break;
			case AUDIO_AC3:     return "AC3"; break;
			case AUDIO_PCM:     return "PCM"; break;
			case AUDIO_AAC:     return "AAC"; break;
			case AUDIO_JESUS:   return "Vorbis"; break;
		}
	}
	return "";
}

int mpeg3_has_video(mpeg3_t *file)
{
	return file->total_vstreams > 0;
}

int mpeg3_total_vstreams(mpeg3_t *file)
{
	return file->total_vstreams;
}

int mpeg3_video_width(mpeg3_t *file,
		int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->width;
	return -1;
}

int mpeg3_video_height(mpeg3_t *file,
		int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->height;
	return -1;
}

float mpeg3_aspect_ratio(mpeg3_t *file, int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->aspect_ratio;
	return 0;
}

float mpeg3_frame_rate(mpeg3_t *file,
		int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->frame_rate;
	return -1;
}

long mpeg3_video_frames(mpeg3_t *file,
		int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->total_frames;
	return -1;
}

long mpeg3_get_frame(mpeg3_t *file,
		int stream)
{
	if(file->total_vstreams)
		return file->vtrack[stream]->current_position;
	return -1;
}

int mpeg3_set_frame(mpeg3_t *file, 
		long frame,
		int stream)
{
	if(file->total_vstreams)
	{
	  file->vtrack[stream]->current_position = frame;
		mpeg3vtrack_seek_frame(file->vtrack[stream], frame);
		return 0;
	}
	return -1;
}

int mpeg3_seek_percentage(mpeg3_t *file, double percentage)
{
	int i;
	for(i = 0; i < file->total_vstreams; i++)
	{
		mpeg3vtrack_seek_percentage(file->vtrack[i], percentage);
	}

	for(i = 0; i < file->total_astreams; i++)
	{
	  mpeg3atrack_seek_percentage(file->atrack[i], percentage);
	}

	return 0;
}

int mpeg3_seek_audio_percentage(mpeg3_t *file, int stream, double percentage)
{
  mpeg3atrack_seek_percentage(file->atrack[stream], percentage);
  return 0;
}

int mpeg3_seek_video_percentage(mpeg3_t *file, int stream, double percentage)
{
  mpeg3vtrack_seek_percentage(file->vtrack[stream], percentage);
  return 0;
}

#if 0
int mpeg3_previous_frame(mpeg3_t *file, int stream)
{
	file->last_type_read = 2;
	file->last_stream_read = stream;

	if(file->total_vstreams)
		return mpeg3video_previous_frame(file->vtrack[stream]->video);

	return 0;
}
#endif

double mpeg3_tell_percentage(mpeg3_t *file)
{
	double percent = 0;
	if(file->last_type_read == 1)
	{
		percent = mpeg3demux_tell_percentage(file->atrack[file->last_stream_read]->demuxer);
	}

	if(file->last_type_read == 2)
	{
		percent = mpeg3demux_tell_percentage(file->vtrack[file->last_stream_read]->demuxer);
	}
	return percent;
}


int mpeg3_end_of_audio(mpeg3_t *file, int stream)
{
	int result = 0;
	result = mpeg3demux_eof(file->atrack[stream]->demuxer);
	return result;
}

int mpeg3_end_of_video(mpeg3_t *file, int stream)
{
	int result = 0;
	result = mpeg3demux_eof(file->vtrack[stream]->demuxer);
	return result;
}



int mpeg3_read_audio_frame (mpeg3_t *file,
			    unsigned char **output,
			    uint32_t *size,
			    uint32_t *max_size,
			    int stream)
{
  int result = -1;
  if (file->total_astreams) {
    result = mpeg3_atrack_read_frame(file->atrack[stream],
				     output, 
				     size,
				     max_size);
    file->last_type_read = 1;
    file->last_stream_read = stream;

  }
  return result;
}
				 
int mpeg3_get_audio_format (mpeg3_t *file, int stream)
{
  if (file->total_astreams) {
    return (file->atrack[stream]->format);
  }
  return AUDIO_UNKNOWN;
}
int mpeg3_read_video_chunk(mpeg3_t *file, 
		unsigned char *output, 
		long *size, 
		long max_size,
		int stream)
{
	int result = 0;
	if(file->total_vstreams)
	{
		result = mpeg3vtrack_read_raw(file->vtrack[stream], output, size, max_size);
		file->last_type_read = 2;
		file->last_stream_read = stream;
	}
	return result;
}

int mpeg3_read_video_chunk_resize (mpeg3_t *file,
				   unsigned char **output,
				   long *size,
				   int stream)
{
	int result = 0;
	if(file->total_vstreams)
	{
		result = mpeg3vtrack_read_raw_resize(file->vtrack[stream], 
						     output, 
						     size);
		file->last_type_read = 2;
		file->last_stream_read = stream;
	}
	return result;
}
void mpeg3_read_video_chunk_cleanup (mpeg3_t *file,
				     int stream)
{
	int result = 0;
	if(file->total_vstreams)
	{
	  mpeg3vtrack_cleanup_frame(file->vtrack[stream]);
	}
}