int32_t Mpeg2FileDefaultAudio(const char* fileName)
{
mpeg2ps_t *mpeg2File = mpeg2ps_init(fileName);
if (!mpeg2File) {
return -1;
}
int32_t audioTracks = mpeg2ps_get_audio_stream_count(mpeg2File);
mpeg2ps_close(mpeg2File);
if (audioTracks <= 0) {
return -1;
}
return 0;
}
int main(int argc, char** argv)
{
char* usageString = "[--video] [--audio] <file-name>\n";
bool dump_audio = false, dump_video = false;
uint audio_stream = 0, video_stream = 0;
char *infilename;
char outfilename[FILENAME_MAX], *suffix;
size_t suffix_len;
FILE *outfile;
mpeg2ps_t *infile;
/* begin processing command line */
char* progName = argv[0];
long cnt = 0;
bool dump = false;
while (1) {
int c = -1;
int option_index = 0;
static struct option long_options[] = {
{ "audio", 2, 0, 'a' },
{ "video", 2, 0, 'v' },
{ "dump", 0, 0, 'd' },
{ "version", 0, 0, 'V' },
{ NULL, 0, 0, 0 }
};
c = getopt_long_only(argc, argv, "a:v:Vd",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'v':
dump_video = true;
if (optarg) {
uint32_t readstream;
if (sscanf(optarg, "%u", &readstream) == 1) {
video_stream = readstream;
}
}
break;
case 'a':
dump_audio = true;
if (optarg) {
uint32_t readstream;
if (sscanf(optarg, "%u", &readstream) == 1) {
audio_stream = readstream;
}
}
break;
case 'd':
dump = true;
break;
case 'V':
fprintf(stderr, "%s - %s version %s\n",
progName, MPEG4IP_PACKAGE, MPEG4IP_VERSION);
exit(0);
default:
fprintf(stderr, "%s: unknown option specified, ignoring: %c\n",
progName, c);
}
}
if ((argc - optind) < 1) {
fprintf(stderr, "usage: %s %s\n", progName, usageString);
exit(1);
}
#if 0
if (dump_audio == 0 && dump_video == 0) {
dump_audio = dump_video = 1;
}
#endif
while (optind < argc) {
infilename = argv[optind];
optind++;
suffix = strrchr(infilename, '.');
suffix_len = suffix - infilename;
if (suffix == NULL) {
fprintf(stderr, "can't find suffix in %s\n", infilename);
continue;
}
infile = mpeg2ps_init(infilename);
if (infile == NULL) {
fprintf(stderr, "%s is not a valid mpeg file\n",
infilename);
continue;
}
uint8_t *buf = NULL;
uint32_t len = 0;
uint64_t ftime;
uint32_t freq_ftime;
uint32_t last_freq_time = 0;
if (dump_audio) {
if (mpeg2ps_get_audio_stream_count(infile) == 0) {
fprintf(stderr, "no audio streams in %s\n", infilename);
} else if (audio_stream >= mpeg2ps_get_audio_stream_count(infile)) {
fprintf(stderr, "audio stream %d does not exist\n", audio_stream);
} else {
char *slash;
slash = strrchr(infilename, '/');
if (slash != NULL) {
slash++;
suffix_len = suffix - slash;
memcpy(outfilename, slash, suffix_len);
} else {
memcpy(outfilename, infilename, suffix_len);
}
mpeg2ps_audio_type_t audio_type =
mpeg2ps_get_audio_stream_type(infile, audio_stream);
switch (audio_type) {
case MPEG_AUDIO_MPEG:
strcpy(outfilename + suffix_len, ".mp3");
break;
case MPEG_AUDIO_AC3:
strcpy(outfilename + suffix_len, ".ac3");
break;
case MPEG_AUDIO_LPCM:
strcpy(outfilename + suffix_len, ".pcm");
break;
default:
break;
}
outfile = fopen(outfilename, FOPEN_WRITE_BINARY);
while (mpeg2ps_get_audio_frame(infile,
audio_stream,
&buf,
&len,
TS_MSEC,
&freq_ftime,
&ftime)) {
printf("audio len %d time %u "U64"\n",
len, freq_ftime, ftime);
if (audio_type == MPEG_AUDIO_LPCM) {
if (last_freq_time != 0) {
if (last_freq_time != freq_ftime) {
printf("error in timestamp %u %u\n", freq_ftime, last_freq_time);
}
}
last_freq_time = freq_ftime + (len / 4);
#if 0
if (last_freq_time + 1152 != freq_ftime) {
printf("error in timestamp %d\n", freq_ftime - last_freq_time);
}
last_freq_time = freq_ftime;
#endif
}
fwrite(buf, len, 1, outfile);
cnt++;
}
fclose(outfile);
printf("%ld audio frames\n", cnt);
}
}
if (dump_video) {
if (mpeg2ps_get_video_stream_count(infile) == 0) {
fprintf(stderr, "no video streams in %s\n", infilename);
} else if (video_stream >= mpeg2ps_get_video_stream_count(infile)) {
fprintf(stderr, "video stream %d does not exist\n", video_stream);
} else {
char *slash;
slash = strrchr(infilename, '/');
if (slash != NULL) {
slash++;
suffix_len = suffix - slash;
memcpy(outfilename, slash, suffix_len);
} else {
memcpy(outfilename, infilename, suffix_len);
}
mpeg2ps_video_type_t video_type =
mpeg2ps_get_video_stream_type(infile, video_stream);
switch (video_type) {
case MPEG_VIDEO_H264:
strcpy(outfilename + suffix_len, ".264");
break;
default:
strcpy(outfilename + suffix_len, ".m2v");
}
outfile = fopen(outfilename, FOPEN_WRITE_BINARY);
cnt = 0;
while (mpeg2ps_get_video_frame(infile,
video_stream,
&buf,
&len,
NULL,
TS_MSEC,
&ftime)) {
printf("video len %d time "U64"\n",
len, ftime);
if (buf[len - 2] == 1 &&
buf[len - 3] == 0 &&
buf[len - 4] == 0) len -= 4;
fwrite(buf, len, 1, outfile);
cnt++;
}
fclose(outfile);
printf("%ld video frames\n", cnt);
}
}
mpeg2ps_close(infile);
}
return 0;
}
static void close_mpeg3_file (void *data)
{
mpeg2ps_t *ps = (mpeg2ps_t *)data;
mpeg2ps_close(ps);
}
int create_media_for_mpeg_file (CPlayerSession *psptr,
const char *name,
int have_audio_driver,
control_callback_vft_t *cc_vft)
{
mpeg2ps_t *file;
int video_streams, audio_streams;
int video_cnt, audio_cnt;
int ix;
codec_plugin_t *plugin;
int video_offset, audio_offset;
int ret;
int sdesc;
file = mpeg2ps_init(name);
if (file == NULL) {
psptr->set_message("file %s is not a valid .mpg file",
name);
return -1;
}
psptr->set_media_close_callback(close_mpeg3_file, (void *)file);
video_streams = mpeg2ps_get_video_stream_count(file);
audio_streams = mpeg2ps_get_audio_stream_count(file);
video_cnt = 0;
if (video_streams > 0) {
plugin = check_for_video_codec(STREAM_TYPE_MPEG_FILE,
"mp2v",
NULL,
mpeg2ps_get_video_stream_type(file, 0),
-1,
NULL,
0,
&config);
if (plugin != NULL) video_cnt = video_streams;
}
for (ix = 0, audio_cnt = 0; ix < audio_streams; ix++) {
plugin = check_for_audio_codec(STREAM_TYPE_MPEG_FILE,
NULL,
NULL,
mpeg2ps_get_audio_stream_type(file, ix),
-1,
NULL,
0,
&config);
if (plugin != NULL) audio_cnt++;
}
video_query_t *vq;
audio_query_t *aq;
if (video_cnt > 0) {
vq = (video_query_t *)malloc(sizeof(video_query_t) * video_cnt);
} else {
vq = NULL;
}
if (have_audio_driver && audio_cnt > 0) {
aq = (audio_query_t *)malloc(sizeof(audio_query_t) * audio_cnt);
} else {
aq = NULL;
}
video_offset = 0;
for (ix = 0; ix < video_cnt; ix++) {
vq[video_offset].track_id = ix;
vq[video_offset].stream_type = STREAM_TYPE_MPEG_FILE;
vq[video_offset].compressor = "mp2v";
vq[video_offset].type = mpeg2ps_get_video_stream_type(file, ix);
vq[video_offset].profile = -1;
vq[video_offset].fptr = NULL;
vq[video_offset].h = mpeg2ps_get_video_stream_height(file, ix);
vq[video_offset].w = mpeg2ps_get_video_stream_width(file, ix);
vq[video_offset].frame_rate = mpeg2ps_get_video_stream_framerate(file, ix);
vq[video_offset].config = NULL;
vq[video_offset].config_len = 0;
vq[video_offset].enabled = 0;
vq[video_offset].reference = NULL;
video_offset++;
}
audio_offset = 0;
if (have_audio_driver) {
for (ix = 0; ix < audio_streams; ix++) {
plugin = check_for_audio_codec(STREAM_TYPE_MPEG_FILE,
NULL,
NULL,
mpeg2ps_get_audio_stream_type(file, ix),
-1,
NULL,
0,
&config);
if (plugin != NULL) {
aq[audio_offset].track_id = ix;
aq[audio_offset].stream_type = STREAM_TYPE_MPEG_FILE;
aq[audio_offset].compressor = NULL;
aq[audio_offset].type = mpeg2ps_get_audio_stream_type(file, ix);
aq[audio_offset].profile = -1;
aq[audio_offset].fptr = NULL;
aq[audio_offset].config = NULL;
aq[audio_offset].config_len = 0;
aq[audio_offset].sampling_freq =
mpeg2ps_get_audio_stream_sample_freq(file, ix);
aq[audio_offset].chans = mpeg2ps_get_audio_stream_channels(file, ix);
aq[audio_offset].enabled = 0;
aq[audio_offset].reference = NULL;
audio_offset++;
} else {
mpeg3f_message(LOG_ERR, "Unsupported audio type %s in track %d",
mpeg2ps_get_audio_stream_name(file, ix), ix);
}
}
}
if (audio_offset == 0 && video_offset == 0) {
psptr->set_message("No playable streams in file");
CHECK_AND_FREE(aq);
CHECK_AND_FREE(vq);
return -1;
}
if (cc_vft && cc_vft->media_list_query != NULL) {
(cc_vft->media_list_query)(psptr, video_offset, vq, audio_offset, aq,
0, NULL);
} else {
if (video_offset > 0) vq[0].enabled = 1;
if (audio_offset > 0) aq[0].enabled = 1;
}
ret = 0;
sdesc = 1;
for (ix = 0; ret >= 0 && ix < video_offset; ix++) {
if (vq[ix].enabled) {
ret = create_mpeg3_video(&vq[ix], file, psptr, sdesc);
if (ret <= 0) {
}
}
}
if (ret >= 0) {
for (ix = 0; ix < audio_offset && ret >= 0; ix++) {
if (aq[ix].enabled) {
ret = create_mpeg3_audio(&aq[ix], file, psptr, sdesc);
if (ret <= 0) {
}
}
}
}
free(vq);
free(aq);
if (ret < 0) {
mpeg2ps_close(file);
return ret;
}
psptr->session_set_seekable(1);
return 0;
}
static GtkWidget* CreateMpeg2TrackMenu(
GtkWidget* menu,
char type,
const char* source,
u_int32_t* pIndex,
u_int32_t* pNumber,
u_int32_t** ppValues)
{
*pIndex = 0;
u_int32_t newTrackNumber = 1;
mpeg2ps_t* mpeg2File = mpeg2ps_init(source);
if (mpeg2File) {
if (type == 'V') {
newTrackNumber = mpeg2ps_get_video_stream_count(mpeg2File);
} else {
newTrackNumber = mpeg2ps_get_audio_stream_count(mpeg2File);
}
}
u_int32_t* newTrackValues =
(u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
char** newTrackNames =
(char**)malloc(sizeof(char*) * newTrackNumber);
if (!mpeg2File) {
newTrackValues[0] = 0;
newTrackNames[0] = strdup("");
} else {
for (u_int8_t i = 0; i < newTrackNumber; i++) {
newTrackValues[i] = i;
char buf[64];
if (type == 'V') {
snprintf(buf, sizeof(buf),
"%u - %u x %u @ %.2f fps",
i + 1,
mpeg2ps_get_video_stream_width(mpeg2File, i),
mpeg2ps_get_video_stream_height(mpeg2File, i),
mpeg2ps_get_video_stream_framerate(mpeg2File, i));
} else {
const char* afmt =
mpeg2ps_get_audio_stream_name(mpeg2File, i);
// use more familar though less accurate name
snprintf(buf, sizeof(buf),
"%u - %s %u channels @ %u Hz",
i + 1,
afmt,
mpeg2ps_get_audio_stream_channels(mpeg2File, i),
mpeg2ps_get_audio_stream_sample_freq(mpeg2File, i));
}
newTrackNames[i] = strdup(buf);
}
mpeg2ps_close(mpeg2File);
}
// (re)create the menu
menu = CreateOptionMenu(
menu,
newTrackNames,
newTrackNumber,
*pIndex,
GTK_SIGNAL_FUNC(on_track_menu_activate));
// free up old names
for (u_int8_t i = 0; i < *pNumber; i++) {
free(trackNames[i]);
}
free(trackNames);
free(*ppValues);
*pNumber = newTrackNumber;
trackNames = newTrackNames;
*ppValues = newTrackValues;
return menu;
}