int CMp4File::create_audio(CPlayerSession *psptr,
audio_query_t *aq,
uint audio_offset,
uint &start_desc)
{
uint ix;
uint64_t IVLength;
CPlayerMedia *mptr;
codec_plugin_t *plugin;
for (ix = 0; ix < audio_offset; ix++) {
if (aq[ix].enabled != 0) {
CMp4AudioByteStream *abyte;
mptr = new CPlayerMedia(psptr, AUDIO_SYNC);
if (mptr == NULL) {
return (-1);
}
/* check if ismacryp */
uint32_t verb = MP4GetVerbosity(m_mp4file);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
if (MP4IsIsmaCrypMediaTrack(m_mp4file, aq[ix].track_id)) {
MP4GetTrackIntegerProperty(m_mp4file,
aq[ix].track_id, "mdia.minf.stbl.stsd.enca.sinf.schi.iSFM.IV-length", &IVLength);
abyte = new CMp4EncAudioByteStream(this, aq[ix].track_id, IVLength);
} else {
abyte = new CMp4AudioByteStream(this, aq[ix].track_id);
}
MP4SetVerbosity(m_mp4file, verb);
audio_info_t *ainfo;
ainfo = (audio_info_t *)malloc(sizeof(audio_info_t));
memset(ainfo, 0, sizeof(*ainfo));
ainfo->freq = aq[ix].sampling_freq;
if (aq[ix].chans != -1) {
ainfo->chans = aq[ix].chans;
}
if ((aq[ix].type == MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE) ||
(aq[ix].type == MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE)) {
ainfo->bitspersample = 16;
}
int ret;
plugin = check_for_audio_codec(STREAM_TYPE_MP4_FILE,
aq[ix].compressor, // media_data field
NULL,
aq[ix].type,
aq[ix].profile,
aq[ix].config,
aq[ix].config_len,
&config);
ret = mptr->create_audio_plugin(plugin,
STREAM_TYPE_MP4_FILE,
aq[ix].compressor,
aq[ix].type,
aq[ix].profile,
NULL, // sdp info
ainfo, // audio info
aq[ix].config,
aq[ix].config_len);
if (ret < 0) {
mp4f_message(LOG_ERR, "Couldn't create audio from plugin %s",
plugin->c_name);
psptr->set_message("Couldn't start audio plugin %s",
plugin->c_name);
delete mptr;
delete abyte;
return -1;
}
ret = mptr->create_media("audio", abyte);
if (ret != 0) {
return (-1);
}
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
char *mp4info = MP4Info(m_mp4file, aq[ix].track_id);
MP4SetVerbosity(m_mp4file, verb);
char *temp = mp4info;
while (*temp != '\0') {
if (isspace(*temp)) *temp = ' ';
if (!isprint(*temp)) *temp = '*';
temp++;
}
psptr->set_session_desc(start_desc, mp4info);
free(mp4info);
start_desc++;
} else {
if (aq[ix].config != NULL) free((void *)aq[ix].config);
}
}
return 0;
}
/*
* Create the media for the quicktime file, and set up some session stuff.
*/
int create_media_for_avi_file (CPlayerSession *psptr,
const char *name,
char *errmsg,
uint32_t errlen,
int have_audio_driver,
control_callback_vft_t *cc_vft)
{
CAviFile *Avifile1 = NULL;
avi_t *avi;
CPlayerMedia *mptr;
avi = AVI_open_input_file(name, 1);
if (avi == NULL) {
snprintf(errmsg, errlen, "%s", AVI_strerror());
player_error_message("%s", AVI_strerror());
return (-1);
}
int video_count = 1;
codec_plugin_t *plugin;
video_query_t vq;
const char *codec_name = AVI_video_compressor(avi);
player_debug_message("Trying avi video codec %s", codec_name);
plugin = check_for_video_codec(STREAM_TYPE_AVI_FILE,
codec_name,
NULL,
-1,
-1,
NULL,
0,
&config);
if (plugin == NULL) {
video_count = 0;
} else {
vq.track_id = 1;
vq.stream_type = STREAM_TYPE_AVI_FILE;
vq.compressor = codec_name;
vq.type = -1;
vq.profile = -1;
vq.fptr = NULL;
vq.h = AVI_video_height(avi);
vq.w = AVI_video_width(avi);
vq.frame_rate = AVI_video_frame_rate(avi);
vq.config = NULL;
vq.config_len = 0;
vq.enabled = 0;
vq.reference = NULL;
}
int have_audio = 0;
int audio_count = 0;
audio_query_t aq;
if (AVI_audio_bytes(avi) != 0) {
have_audio = 1;
plugin = check_for_audio_codec(STREAM_TYPE_AVI_FILE,
NULL,
NULL,
AVI_audio_format(avi),
-1,
NULL,
0,
&config);
if (plugin != NULL) {
audio_count = 1;
aq.track_id = 1;
aq.stream_type = STREAM_TYPE_AVI_FILE;
aq.compressor = NULL;
aq.type = AVI_audio_format(avi);
aq.profile = -1;
aq.fptr = NULL;
aq.sampling_freq = AVI_audio_rate(avi);
aq.chans = AVI_audio_channels(avi);
aq.config = NULL;
aq.config_len = 0;
aq.enabled = 0;
aq.reference = NULL;
}
}
if (cc_vft != NULL && cc_vft->media_list_query != NULL) {
(cc_vft->media_list_query)(psptr, video_count, &vq, audio_count, &aq);
} else {
if (video_count != 0) vq.enabled = 1;
if (audio_count != 0) aq.enabled = 1;
}
if ((video_count == 0 || vq.enabled == 0) &&
(audio_count == 0 || aq.enabled == 0)) {
snprintf(errmsg, errlen, "No audio or video tracks enabled or playable");
AVI_close(avi);
return -1;
}
Avifile1 = new CAviFile(name, avi, vq.enabled, audio_count);
psptr->set_media_close_callback(close_avi_file, Avifile1);
if (video_count != 0 && vq.enabled) {
mptr = new CPlayerMedia(psptr);
if (mptr == NULL) {
return (-1);
}
video_info_t *vinfo = MALLOC_STRUCTURE(video_info_t);
if (vinfo == NULL)
return (-1);
vinfo->height = vq.h;
vinfo->width = vq.w;
player_debug_message("avi file h %d w %d frame rate %g",
vinfo->height,
vinfo->width,
vq.frame_rate);
plugin = check_for_video_codec(STREAM_TYPE_AVI_FILE,
codec_name,
NULL,
-1,
-1,
NULL,
0,
&config);
int ret;
ret = mptr->create_video_plugin(plugin,
STREAM_TYPE_AVI_FILE,
codec_name,
-1,
-1,
NULL,
vinfo,
NULL,
0);
if (ret < 0) {
snprintf(errmsg, errlen, "Failed to create video plugin %s",
codec_name);
player_error_message("Failed to create plugin data");
delete mptr;
return -1;
}
CAviVideoByteStream *vbyte = new CAviVideoByteStream(Avifile1);
if (vbyte == NULL) {
delete mptr;
return (-1);
}
vbyte->config(AVI_video_frames(avi), vq.frame_rate);
ret = mptr->create(vbyte, TRUE, errmsg, errlen);
if (ret != 0) {
return (-1);
}
}
int seekable = 1;
if (have_audio_driver > 0 && audio_count > 0 && aq.enabled != 0) {
plugin = check_for_audio_codec(STREAM_TYPE_AVI_FILE,
NULL,
NULL,
aq.type,
-1,
NULL,
0,
&config);
CAviAudioByteStream *abyte;
mptr = new CPlayerMedia(psptr);
if (mptr == NULL) {
return (-1);
}
audio_info_t *ainfo;
ainfo = MALLOC_STRUCTURE(audio_info_t);
ainfo->freq = aq.sampling_freq;
ainfo->chans = aq.chans;
ainfo->bitspersample = AVI_audio_bits(avi);
int ret;
ret = mptr->create_audio_plugin(plugin,
aq.stream_type,
aq.compressor,
aq.type,
aq.profile,
NULL,
ainfo,
NULL,
0);
if (ret < 0) {
delete mptr;
player_error_message("Couldn't create audio from plugin %s",
plugin->c_name);
return -1;
}
abyte = new CAviAudioByteStream(Avifile1);
ret = mptr->create(abyte, FALSE, errmsg, errlen);
if (ret != 0) {
return (-1);
}
seekable = 0;
}
psptr->session_set_seekable(seekable);
if (audio_count == 0 && have_audio != 0) {
snprintf(errmsg, errlen, "Unknown Audio Codec in avi file ");
return (1);
}
if (video_count != 1) {
snprintf(errmsg, errlen, "Unknown Video Codec %s in avi file",
codec_name);
return (1);
}
return (0);
}
static int create_mpeg3_audio (audio_query_t * aq,
mpeg2ps_t *afile,
CPlayerSession *psptr,
int &sdesc)
{
CPlayerMedia *mptr;
codec_plugin_t *plugin;
int ret;
plugin = check_for_audio_codec(STREAM_TYPE_MPEG_FILE,
NULL,
NULL,
aq->type,
-1,
NULL,
0,
&config);
if (plugin == NULL) {
psptr->set_message("Can't find plugin for mpeg audio format %s",
mpeg2ps_get_audio_stream_name(afile, aq->track_id));
return 0;
}
mptr = new CPlayerMedia(psptr, AUDIO_SYNC);
if (mptr == NULL) {
psptr->set_message("Could not create video media");
return -1;
}
audio_info_t *ainfo;
ainfo = MALLOC_STRUCTURE(audio_info_t);
ainfo->freq = aq->sampling_freq;
ainfo->chans = aq->chans;
ainfo->bitspersample = 16;
char buffer[80];
snprintf(buffer, 80, "%s Audio, %d, %d channels",
mpeg2ps_get_audio_stream_name(afile, aq->track_id),
ainfo->freq,
ainfo->chans);
psptr->set_session_desc(sdesc, buffer);
sdesc++;
ret = mptr->create_audio_plugin(plugin, aq->stream_type,
aq->compressor,
aq->type, aq->profile,
NULL, ainfo, NULL, 0);
if (ret < 0) {
mpeg3f_message(LOG_ERR, "Failed to create audio plugin");
psptr->set_message("Failed to create audio plugin");
free(ainfo);
delete mptr;
return -1;
}
CMpeg3AudioByteStream *abyte;
abyte = new CMpeg3AudioByteStream(afile, aq->track_id);
if (abyte == NULL) {
psptr->set_message("Failed to create audio bytestream");
return -1;
}
ret = mptr->create_media("audio", abyte);
if (ret != 0) {
psptr->set_message("Couldn't create audio media");
return -1;
}
return 1;
}
int CMpeg2tFile::create_audio (CPlayerSession *psptr,
mpeg2t_t *decoder,
audio_query_t *aq,
uint audio_offset,
int &sdesc)
{
uint ix;
CPlayerMedia *mptr;
codec_plugin_t *plugin;
int created = 0;
for (ix = 0; ix < audio_offset; ix++) {
mpeg2t_pid_t *pidptr;
mpeg2t_es_t *es_pid;
pidptr = mpeg2t_lookup_pid(decoder,aq[ix].track_id);
if (pidptr->pak_type != MPEG2T_ES_PAK) {
mpeg2f_message(LOG_CRIT, "mpeg2t video type is not es pak - pid %x",
aq[ix].track_id);
exit(1);
}
es_pid = (mpeg2t_es_t *)pidptr;
if (aq[ix].enabled != 0 && created == 0) {
created = 1;
mptr = new CPlayerMedia(psptr, AUDIO_SYNC);
if (mptr == NULL) {
return (-1);
}
audio_info_t *ainfo;
ainfo = MALLOC_STRUCTURE(audio_info_t);
ainfo->freq = aq[ix].sampling_freq;
ainfo->chans = aq[ix].chans;
ainfo->bitspersample = 0;
plugin = check_for_audio_codec(STREAM_TYPE_MPEG2_TRANSPORT_STREAM,
NULL,
NULL,
aq[ix].type,
aq[ix].profile,
aq[ix].config,
aq[ix].config_len,
&config);
int ret = mptr->create_audio_plugin(plugin,
STREAM_TYPE_MPEG2_TRANSPORT_STREAM,
NULL,
aq[ix].type,
aq[ix].profile,
NULL, // sdp info
ainfo, // video info
aq[ix].config,
aq[ix].config_len);
if (ret < 0) {
mpeg2f_message(LOG_ERR, "Failed to create plugin data");
psptr->set_message("Failed to start plugin");
delete mptr;
return -1;
}
CMpeg2fAudioByteStream *abyte;
abyte = new CMpeg2fAudioByteStream(this, es_pid);
if (abyte == NULL) {
mpeg2f_message(LOG_CRIT, "failed to create byte stream");
delete mptr;
return (-1);
}
ret = mptr->create_media("audio", abyte, false);
if (ret != 0) {
mpeg2f_message(LOG_CRIT, "failed to create from file");
return (-1);
}
if (es_pid->info_loaded) {
char buffer[80];
if (mpeg2t_write_stream_info(es_pid, buffer, 80) >= 0) {
psptr->set_session_desc(sdesc, buffer);
sdesc++;
}
}
mpeg2t_set_frame_status(es_pid, MPEG2T_PID_SAVE_FRAME);
} else {
mpeg2t_set_frame_status(es_pid, MPEG2T_PID_NOTHING);
}
}
return created;
}