Google Git
Sign in
coral / imx-gst1.0-plugin / refs/heads/alpha / . / plugins / aiurdemux / aiurdemux.c
blob: cca8351a7a85435d2c02a7a2ff1766bec3039eed [file] [log] [blame] [edit]
/*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* Copyright (c) 2013-2015, Freescale Semiconductor, Inc.
* Copyright 2017 NXP
*/
/*
* Module Name: aiurdemux.c
*
* Description: Implementation of unified parser gstreamer plugin
*
* Portability: This code is written for Linux OS and Gstreamer
*/
/*
* Changelog:
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aiurdemux.h"
GST_DEBUG_CATEGORY (aiurdemux_debug);
typedef struct{
guint32 type;
guint32 subtype;
const gchar* codec_str;
const gchar* mime;
}AiurdemuxCodecStruct;
static AiurdemuxCodecStruct aiurdemux_videocodec_tab[] ={
{VIDEO_H263, 0, "H.263", "video/x-h263, variant=(string)itu"},
{VIDEO_H264, 0, "H.264/AVC", "video/x-h264, parsed = (boolean)true, alignment=(string)au"},
{VIDEO_MPEG2, 0, "MPEG2", "video/mpeg, systemstream = (boolean)false, parsed = (boolean)true, mpegversion=(int)2"},
{VIDEO_MPEG4, 0, "MPEG4", "video/mpeg, systemstream = (boolean)false, parsed = (boolean)true, mpegversion=(int)4"},
{VIDEO_JPEG, 0, "JPEG", "image/jpeg"},
{VIDEO_MJPG, VIDEO_MJPEG_FORMAT_A, "Motion JPEG format A", "image/jpeg"},
{VIDEO_MJPG, VIDEO_MJPEG_FORMAT_B, "Motion JPEG format B", "image/jpeg"},
{VIDEO_MJPG, VIDEO_MJPEG_2000, "Motion JPEG 2000", "image/x-j2c"},
{VIDEO_MJPG, 0, "Motion JPEG format unknow", "image/jpeg"},
{VIDEO_DIVX, VIDEO_DIVX3, "Divx3", "video/x-divx, divxversion=(int)3"},
{VIDEO_DIVX, VIDEO_DIVX4, "Divx4", "video/x-divx, divxversion=(int)4"},
{VIDEO_DIVX, VIDEO_DIVX5_6, "Divx", "video/x-divx, divxversion=(int)5"},
{VIDEO_DIVX, 0, "Divx", "video/x-divx, divxversion=(int)5"},
{VIDEO_XVID, 0, "Xvid", "video/x-xvid"},
{VIDEO_WMV, VIDEO_WMV7, "WMV7", "video/x-wmv, wmvversion=(int)1, format=(string)WMV1"},
{VIDEO_WMV, VIDEO_WMV8, "WMV8", "video/x-wmv, wmvversion=(int)2, format=(string)WMV2"},
{VIDEO_WMV, VIDEO_WMV9, "WMV9", "video/x-wmv, wmvversion=(int)3, format=(string)WMV3"},
{VIDEO_WMV, VIDEO_WVC1, "VC1", "video/x-wmv, wmvversion=(int)3, format=(string)WVC1"},
{VIDEO_WMV, 0, NULL, NULL},
{VIDEO_REAL, 0, "RealVideo", "video/x-pn-realvideo"},
{VIDEO_SORENSON_H263, 0, "Sorenson H.263", "video/x-flash-video, flvversion=(int)1"},
{VIDEO_FLV_SCREEN, 0, "Flash Screen", "video/x-flash-screen"},
{VIDEO_ON2_VP, VIDEO_VP6A, "VP6 Alpha", "video/x-vp6-alpha"},
{VIDEO_ON2_VP, VIDEO_VP6, "VP6 Flash", "video/x-vp6-flash"},
{VIDEO_ON2_VP, VIDEO_VP8, "VP8", "video/x-vp8"},
{VIDEO_ON2_VP, VIDEO_VP9, "VP9", "video/x-vp9"},
{VIDEO_ON2_VP, 0, NULL, NULL},
{VIDEO_HEVC, 0, "H.265/HEVC", "video/x-h265, parsed = (boolean)true, alignment=(string)au"},
{VIDEO_AVS, 0, "AVS", "video/x-cavs"},
};
static GstStaticPadTemplate gst_aiurdemux_videosrc_template =
GST_STATIC_PAD_TEMPLATE ("video_%u",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate gst_aiurdemux_audiosrc_template =
GST_STATIC_PAD_TEMPLATE ("audio_%u",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate gst_aiurdemux_subsrc_template =
GST_STATIC_PAD_TEMPLATE ("subtitle_%u",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
GST_STATIC_CAPS_ANY);
static GstsutilsOptionEntry g_aiurdemux_option_table[] = {
{PROP_PROGRAM_NUMBER, "program-number",
"program-number",
"Program number to demux for (-1 to ignore), valid only when multiprogram-enabled=false",
G_TYPE_INT,
G_STRUCT_OFFSET (AiurDemuxOption, program_number),
"-1", "-1", G_MAXINT_STR},
{PROP_MULTIPROGRAM_ENABLED, "multiprogram-enabled", "multiprogram enabled",
"enable/disable multiprogram",
G_TYPE_BOOLEAN, G_STRUCT_OFFSET (AiurDemuxOption, multiprogram_enabled),
"false"},
{PROP_PROGRAM_MASK, "program-mask", "program mask",
"set program track bit mask (valid for first 32 programs, 0 for enable all)",
G_TYPE_UINT,
G_STRUCT_OFFSET (AiurDemuxOption, program_mask),
"0x0", "0", "0xffffffff"},
{PROP_INTERLEAVE_QUEUE_SIZE, "interleave-queue-size", "interleave queue size",
"set length of interleave queue in bytes for file read mode only",
G_TYPE_UINT,
G_STRUCT_OFFSET (AiurDemuxOption, interleave_queue_size),
"10240000", "0", G_MAXUINT_STR},
{PROP_STREAMING_LATENCY, "streaming_latency", "latency for streaming",
"set the latency in ms seconds for streaming mode",
G_TYPE_UINT,
G_STRUCT_OFFSET (AiurDemuxOption, streaming_latency),
"400", "0", G_MAXUINT_STR},
{PROP_INDEX_ENABLED, "enable-index", "enable index file for clips",
"enable/disable index file for clips",
G_TYPE_BOOLEAN,
G_STRUCT_OFFSET (AiurDemuxOption, index_enabled),
"false"},
{PROP_DISABLE_VORBIS_CODEC_DATA, "disable_vorbis_codec_data", "do not send vorbis codec data",
"whether to parse vorbis codec data to three buffers to send",
G_TYPE_BOOLEAN,
G_STRUCT_OFFSET (AiurDemuxOption, disable_vorbis_codec_data),
"true"},
{PROP_LOW_LATENCY_TOLERANCE, "low_latency_tolerance", "low latency tolarance",
"-1: disable low latency function, 0-streaming_latency: tolarance in ms seconds for time diff",
G_TYPE_INT,
G_STRUCT_OFFSET (AiurDemuxOption, low_latency_tolerance),
"-1", "-1", G_MAXINT_STR},
{-1, NULL, NULL, NULL, 0, 0, NULL} /* terminator */
};
typedef struct
{
gint core_tag;
gint format;
const gchar *gst_tag_name;
const gchar *print_string;
} AiurDemuxTagEntry;
static AiurDemuxTagEntry g_user_data_entry[] = {
{USER_DATA_TITLE, USER_DATA_FORMAT_UTF8, GST_TAG_TITLE,
"Title : %s\n"},
{USER_DATA_LANGUAGE, USER_DATA_FORMAT_UTF8, GST_TAG_LANGUAGE_CODE,
"Langurage : %s\n"},
{USER_DATA_GENRE, USER_DATA_FORMAT_UTF8, GST_TAG_GENRE,
"Genre : %s\n"},
{USER_DATA_ARTIST, USER_DATA_FORMAT_UTF8, GST_TAG_ARTIST,
"Artist : %s\n"},
{USER_DATA_COPYRIGHT, USER_DATA_FORMAT_UTF8, GST_TAG_COPYRIGHT,
"Copy Right : %s\n"},
{USER_DATA_COMMENTS, USER_DATA_FORMAT_UTF8, GST_TAG_COMMENT,
"Comments : %s\n"},
{USER_DATA_CREATION_DATE, USER_DATA_FORMAT_UTF8, GST_TAG_DATE,
"Creation Date : %s\n"},
{USER_DATA_ALBUM, USER_DATA_FORMAT_UTF8, GST_TAG_ALBUM,
"Album : %s\n"},
{USER_DATA_VCODECNAME, USER_DATA_FORMAT_UTF8, GST_TAG_VIDEO_CODEC,
"Video Codec Name : %s\n"},
{USER_DATA_ACODECNAME, USER_DATA_FORMAT_UTF8, GST_TAG_AUDIO_CODEC,
"Audio Codec Name : %s\n"},
{USER_DATA_ARTWORK, USER_DATA_FORMAT_JPEG, GST_TAG_IMAGE,
"Found Artwork : foamrt %d , %d bytes\n"},
{USER_DATA_COMPOSER, USER_DATA_FORMAT_UTF8, GST_TAG_COMPOSER,
"Composer : %s\n"},
//{USER_DATA_DIRECTOR, USER_DATA_FORMAT_UTF8, ?, "Director : %s\n"}, /* tag is not defined */
//{USER_DATA_INFORMATION, USER_DATA_FORMAT_UTF8, ?, "Information : %s\n"}, /* tag is not defined */
//{USER_DATA_CREATOR, USER_DATA_FORMAT_UTF8, ?, "Creator : %s\n"}, /* tag is not defined */
//{USER_DATA_PRODUCER, USER_DATA_FORMAT_UTF8, ?, "Producer : %s\n"}, /* tag is not defined */
{USER_DATA_PERFORMER, USER_DATA_FORMAT_UTF8, GST_TAG_PERFORMER,
"Performer : %s\n"},
//{USER_DATA_REQUIREMENTS, USER_DATA_FORMAT_UTF8, ?, "Requirements : %s\n"}, /* tag is not defined */
//{USER_DATA_SONGWRITER, USER_DATA_FORMAT_UTF8, ?, "Song Writer : %s\n"}, /* tag is not defined */
//{USER_DATA_MOVIEWRITER, USER_DATA_FORMAT_UTF8, ?, "Movie Writer : %s\n"}, /* tag is not defined */
{USER_DATA_TOOL, USER_DATA_FORMAT_UTF8, GST_TAG_APPLICATION_NAME,
"Writing Application : %s\n"},
{USER_DATA_DESCRIPTION, USER_DATA_FORMAT_UTF8, GST_TAG_DESCRIPTION,
"Description : %s\n"},
{USER_DATA_TRACKNUMBER, USER_DATA_FORMAT_UTF8, GST_TAG_TRACK_NUMBER,
"Track Number : %s\n"},
{USER_DATA_TOTALTRACKNUMBER, USER_DATA_FORMAT_UTF8, GST_TAG_TRACK_COUNT,
"Track Count : %s\n"},
{USER_DATA_LOCATION, USER_DATA_FORMAT_UTF8, -1,
"Location : %s\n"},
{USER_DATA_KEYWORDS, USER_DATA_FORMAT_UTF8, GST_TAG_KEYWORDS,
"Keywords : %s\n"},
{USER_DATA_ALBUMARTIST, USER_DATA_FORMAT_UTF8, GST_TAG_ALBUM_ARTIST,
"Album Artist : %s\n"},
{USER_DATA_DISCNUMBER, USER_DATA_FORMAT_UTF8, GST_TAG_ALBUM_VOLUME_NUMBER,
"Disc Number : %s\n"},
{USER_DATA_RATING, USER_DATA_FORMAT_UTF8, GST_TAG_USER_RATING,
"User Rating : %s\n"},
};
#define gst_aiurdemux_parent_class parent_class
G_DEFINE_TYPE (GstAiurDemux, gst_aiurdemux, GST_TYPE_ELEMENT);
static void gst_aiurdemux_finalize (GObject * object);
static GstStateChangeReturn gst_aiurdemux_change_state (GstElement * element,
GstStateChange transition);
static GstFlowReturn gst_aiurdemux_chain (GstPad * sinkpad, GstObject * parent,
GstBuffer * inbuf);
static gboolean gst_aiurdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent,
GstEvent * event);
static gboolean gst_aiurdemux_handle_src_event (GstPad * sinkpad, GstObject * parent,
GstEvent * event);
static gboolean
gst_aiurdemux_handle_src_query (GstPad * pad, GstObject * parent, GstQuery * query);
static void
gst_aiurdemux_push_tags (GstAiurDemux * demux, AiurDemuxStream * stream);
static void
gst_aiurdemux_push_event (GstAiurDemux * demux, GstEvent * event);
static GstPadTemplate *gst_aiurdemux_sink_pad_template (void);
static gboolean aiurdemux_sink_activate (GstPad * sinkpad,GstObject * parent);
static gboolean aiurdemux_sink_activate_mode (GstPad * sinkpad,
GstObject * parent, GstPadMode mode, gboolean active);
static gboolean aiurdemux_sink_activate_pull (GstPad * sinkpad, GstObject * parent,
gboolean active);
static gboolean aiurdemux_sink_activate_push (GstPad * sinkpad, GstObject * parent,
gboolean active);
gpointer aiurdemux_loop_push (gpointer * data);
static void aiurdemux_pull_task (GstPad * pad);
static void aiurdemux_push_task (GstAiurDemux * demux);
static gboolean gst_aiurdemux_setcaps (GstPad * pad, GstObject * parent, GstCaps * caps);
static GstFlowReturn aiurdemux_loop_state_probe (GstAiurDemux * demux);
static GstFlowReturn aiurdemux_loop_state_init (GstAiurDemux * demux);
static GstFlowReturn aiurdemux_loop_state_header (GstAiurDemux * demux);
static GstFlowReturn aiurdemux_loop_state_movie (GstAiurDemux * demux);
static gboolean aiurdemux_set_readmode (GstAiurDemux * demux);
static gboolean
aiurdemux_parse_programs (GstAiurDemux * demux);
static gboolean
aiurdemux_parse_pmt (GstAiurDemux * demux);
gboolean
aiurdemux_parse_program_info (GstAiurDemux * demux);
static void
aiurdemux_select_programs (GstAiurDemux * demux);
static GstTagList * aiurdemux_add_user_tags (GstAiurDemux * demux);
static int aiurdemux_parse_streams (GstAiurDemux * demux);
static void aiurdemux_parse_video (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index);
static void aiurdemux_parse_audio (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index);
static void aiurdemux_parse_text (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index);
static void aiurdemux_check_interleave_stream_eos (GstAiurDemux * demux);
static void
_gst_buffer_copy_into_mem (GstBuffer * dest, gsize offset, const guint8 * src,
gsize size);
static GstFlowReturn aiurdemux_read_buffer(GstAiurDemux * demux, uint32* track_idx,
AiurDemuxStream** stream_out);
static GstFlowReturn aiurdemux_parse_vorbis_codec_data(GstAiurDemux * demux, AiurDemuxStream* stream);
static gint aiurdemux_choose_next_stream (GstAiurDemux * demux);
static AiurDemuxStream * aiurdemux_trackidx_to_stream (GstAiurDemux * demux, guint32 stream_idx);
static void
aiurdemux_check_start_offset (GstAiurDemux * demux, AiurDemuxStream * stream);
static void
aiurdemux_adjust_timestamp (GstAiurDemux * demux, AiurDemuxStream * stream,
GstBuffer * buffer);
static void
aiurdemux_update_stream_position (GstAiurDemux * demux,
AiurDemuxStream * stream, GstBuffer * buffer);
static void
aiurdemux_send_stream_newsegment (GstAiurDemux * demux,
AiurDemuxStream * stream);
static GstFlowReturn
aiurdemux_send_stream_eos (GstAiurDemux * demux, AiurDemuxStream * stream);
static GstFlowReturn
aiurdemux_send_stream_eos_all (GstAiurDemux * demux);
static GstFlowReturn aiurdemux_push_pad_buffer (GstAiurDemux * demux, AiurDemuxStream * stream,
GstBuffer * buffer);
static GstFlowReturn
aiurdemux_combine_flows (GstAiurDemux * demux, AiurDemuxStream * stream,
GstFlowReturn ret);
static void aiurdemux_reset_stream (GstAiurDemux * demux, AiurDemuxStream * stream);
static gboolean
gst_aiurdemux_convert_seek (GstPad * pad, GstFormat * format,
GstSeekType cur_type, gint64 * cur, GstSeekType stop_type, gint64 * stop);
static gboolean
gst_aiurdemux_perform_seek (GstAiurDemux * demux, GstSegment * segment,
gint accurate);
static gboolean
aiurdemux_do_push_seek (GstAiurDemux * demux, GstPad * pad,
GstEvent * event);
static gboolean
aiurdemux_do_seek (GstAiurDemux * demux, GstPad * pad, GstEvent * event);
static gboolean
gst_aiurdemux_get_duration (GstAiurDemux * demux, gint64 * duration);
static void
aiurdemux_send_pending_events (GstAiurDemux * demux);
static void aiurdemux_release_resource (GstAiurDemux * demux);
static GstFlowReturn gst_aiurdemux_close_core (GstAiurDemux * demux);
#define AIUR_MEDIATYPE2STR(media) \
(((media)==MEDIA_VIDEO)?"video":(((media)==MEDIA_AUDIO)?"audio":"subtitle"))
#define AIUR_CORETS_2_GSTTS(ts) (((ts)==PARSER_UNKNOWN_TIME_STAMP)? GST_CLOCK_TIME_NONE : (ts*1000))
#define AIUR_GSTTS_2_CORETS(ts) ((ts)/1000)
#define AIUR_COREDURATION_2_GSTDURATION(ts) (((ts)==PARSER_UNKNOWN_DURATION)? 0 : (ts*1000))
#define AIUR_RESET_SAMPLE_STAT(stat)\
do {\
(stat).start = GST_CLOCK_TIME_NONE;\
(stat).duration = 0;\
(stat).flag = 0;\
}while(0)
#define AIUR_UPDATE_SAMPLE_STAT(stat,timestamp, dura, sflag)\
do {\
if (((stat).start==GST_CLOCK_TIME_NONE) && \
((timestamp)!=GST_CLOCK_TIME_NONE))\
(stat).start = (timestamp);\
(stat).duration += dura;\
(stat).flag |= sflag;\
}while(0)
#define MARK_STREAM_EOS(demux, stream)\
do {\
(stream)->valid = FALSE;\
(stream)->pending_eos = TRUE;\
(demux)->pending_event = TRUE;\
}while(0)
#define AIURDEMUX_FUNCTION_IMPLEMENTATION 1
static void gst_aiurdemux_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAiurDemux *self = GST_AIURDEMUX (object);
if (gstsutils_options_set_option (g_aiurdemux_option_table,
(gchar *) & self->option, prop_id, value) == FALSE) {
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void gst_aiurdemux_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstAiurDemux *self = GST_AIURDEMUX (object);
if (gstsutils_options_get_option (g_aiurdemux_option_table,
(gchar *) & self->option, prop_id, value) == FALSE) {
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void gst_aiurdemux_class_init (GstAiurDemuxClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_peek_parent (klass);
gobject_class->finalize = gst_aiurdemux_finalize;
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_aiurdemux_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_aiurdemux_get_property);
gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_aiurdemux_change_state);
gstsutils_options_install_properties_by_options (g_aiurdemux_option_table,
gobject_class);
gst_element_class_add_pad_template (gstelement_class,
gst_aiurdemux_sink_pad_template ());
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_aiurdemux_videosrc_template));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_aiurdemux_audiosrc_template));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_aiurdemux_subsrc_template));
gst_element_class_set_static_metadata (gstelement_class, "Aiur universal demuxer",
"Codec/Demuxer",
"demux container file to video, audio, and subtitle",
"FreeScale Multimedia Team <shamm@freescale.com>");
GST_DEBUG_CATEGORY_INIT (aiurdemux_debug, "aiurdemux", 0, "aiurdemux plugin");
}
static void gst_aiurdemux_init (GstAiurDemux * demux)
{
demux->sinkpad =
gst_pad_new_from_template (gst_aiurdemux_sink_pad_template (), "sink");
gst_pad_set_activate_function (demux->sinkpad, aiurdemux_sink_activate);
gst_pad_set_activatemode_function (demux->sinkpad,
aiurdemux_sink_activate_mode);
gst_pad_set_chain_function (demux->sinkpad,
GST_DEBUG_FUNCPTR (gst_aiurdemux_chain));
gst_pad_set_event_function (demux->sinkpad,
GST_DEBUG_FUNCPTR (gst_aiurdemux_handle_sink_event));
gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->sinkpad);
gstsutils_options_load_default (g_aiurdemux_option_table,
(gchar *) & demux->option);
gstsutils_options_load_from_keyfile (g_aiurdemux_option_table,
(gchar *) & demux->option, (gchar *)FSL_GST_CONF_DEFAULT_FILENAME,
(gchar *)"aiurdemux");
demux->state = AIURDEMUX_STATE_PROBE;
demux->pullbased = FALSE;
demux->core_interface = NULL;
demux->core_handle = NULL;
demux->thread = NULL;
demux->stream_cache = gst_aiur_stream_cache_new (AIUR_STREAM_CACHE_SIZE,
AIUR_STREAM_CACHE_SIZE_MAX, demux);
g_mutex_init (&demux->runmutex);
g_mutex_init (&demux->seekmutex);
demux->play_mode = AIUR_PLAY_MODE_NORMAL;
GST_LOG_OBJECT(demux,"gst_aiurdemux_init");
gst_segment_init (&demux->segment, GST_FORMAT_TIME);
}
static void gst_aiurdemux_finalize (GObject * object)
{
GstAiurDemux *demux = GST_AIURDEMUX (object);
GST_LOG_OBJECT(demux,"gst_aiurdemux_finalize");
if (demux->stream_cache) {
gst_mini_object_unref (GST_MINI_OBJECT_CAST (demux->stream_cache));
g_free(demux->stream_cache);
demux->stream_cache = NULL;
}
g_mutex_clear (&demux->runmutex);
g_mutex_clear (&demux->seekmutex);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GstStateChangeReturn gst_aiurdemux_change_state (GstElement * element,
GstStateChange transition)
{
GstAiurDemux *demux = GST_AIURDEMUX (element);
GstStateChangeReturn result = GST_STATE_CHANGE_FAILURE;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
GST_DEBUG_OBJECT(demux,"change_state READY_TO_PAUSED");
demux->clock_offset = GST_CLOCK_TIME_NONE;
demux->media_offset = 0;
demux->avg_diff = 0;
demux->start_time = GST_CLOCK_TIME_NONE;
demux->tag_list = gst_tag_list_new_empty ();
aiurcontent_new(&demux->content_info);
break;
default:
GST_LOG_OBJECT(demux,"change_state transition=%x",transition);
break;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
{
GST_DEBUG_OBJECT(demux,"change_state PAUSED_TO_READY");
demux->state = AIURDEMUX_STATE_PROBE;
demux->pullbased = FALSE;
if (demux->tag_list)
gst_tag_list_unref (demux->tag_list);
aiurdemux_release_resource (demux);
gst_aiurdemux_close_core (demux);
aiurcontent_release(demux->content_info);
demux->content_info = NULL;
gst_segment_init (&demux->segment, GST_FORMAT_TIME);
demux->play_mode = AIUR_PLAY_MODE_NORMAL;
demux->valid_mask = 0;
demux->n_streams = 0;
demux->n_video_streams = 0;
demux->n_audio_streams = 0;
demux->n_sub_streams = 0;
demux->sub_read_cnt = 0;
demux->sub_read_ready = 0;
break;
}
default:
break;
}
return result;
}
static GstFlowReturn gst_aiurdemux_chain (GstPad * sinkpad, GstObject * parent,
GstBuffer * inbuf)
{
GstAiurDemux *demux;
demux = GST_AIURDEMUX (parent);
if (inbuf) {
gst_aiur_stream_cache_add_buffer (demux->stream_cache, inbuf);
}
return GST_FLOW_OK;
}
static gboolean gst_aiurdemux_handle_sink_event(GstPad * sinkpad, GstObject * parent,
GstEvent * event)
{
GstAiurDemux *demux = GST_AIURDEMUX (parent);
gboolean res = TRUE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
{
const GstSegment* segment;
gst_event_parse_segment(event,&segment);
/* we only expect a BYTE segment, e.g. following a seek */
if (segment->format == GST_FORMAT_BYTES) {
if (demux->pullbased == FALSE) {
gst_aiur_stream_cache_set_segment (demux->stream_cache, segment->start, segment->stop);
}
} else if (segment->format == GST_FORMAT_TIME) {
GST_DEBUG_OBJECT (demux, "handling new segment from%lld", segment->start);
goto exit;
} else {
GST_DEBUG_OBJECT (demux, "unsupported segment format, ignoring");
goto exit;
}
GST_DEBUG_OBJECT (demux,
"Pushing newseg rate %g, "
"format %d, start %"
GST_TIME_FORMAT ", " "stop %" GST_TIME_FORMAT,
segment->rate, GST_FORMAT_TIME,
GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop));
if (segment->stop < segment->start) {
gst_event_unref (event);
return FALSE;
}
/* clear leftover in current segment, if any */
exit:
gst_event_unref (event);
res = TRUE;
goto drop;
break;
}
case GST_EVENT_FLUSH_START:
case GST_EVENT_FLUSH_STOP:
{
gint i;
/* reset flow return, e.g. following seek */
for (i = 0; i < demux->n_streams; i++) {
demux->streams[i]->last_ret = GST_FLOW_OK;
}
gst_event_unref (event);
res = TRUE;
goto drop;
break;
}
case GST_EVENT_EOS:
/* If we are in push mode, and get an EOS before we've seen any streams,
* then error out - we have nowhere to send the EOS */
if (demux->pullbased) {
gint i;
gboolean has_valid_stream = FALSE;
for (i = 0; i < demux->n_streams; i++) {
if (demux->streams[i]->pad != NULL) {
has_valid_stream = TRUE;
break;
}
}
if (!has_valid_stream){
;// gst_aiurdemux_post_no_playable_stream_error (demux);
}
} else {
gst_aiur_stream_cache_seteos (demux->stream_cache, TRUE);
gst_event_unref (event);
goto drop;
}
break;
case GST_EVENT_CAPS:
{
GstCaps *caps = NULL;
gst_event_parse_caps (event, &caps);
res = gst_aiurdemux_setcaps(sinkpad, parent, caps);
gst_event_unref (event);
goto drop;
break;
}
default:
GST_LOG_OBJECT(demux,"gst_aiurdemux_handle_sink_event event=%x",GST_EVENT_TYPE (event));
break;
}
res = gst_pad_event_default (demux->sinkpad, parent, event);
drop:
return res;
}
static gboolean gst_aiurdemux_handle_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res = TRUE;
GstAiurDemux *demux = GST_AIURDEMUX (parent);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:
if (!demux->seekable || !aiurcontent_is_seelable(demux->content_info)) {
goto not_support;
}
if ((demux->state == AIURDEMUX_STATE_MOVIE) && demux->n_streams) {
if (demux->pullbased) {
res = aiurdemux_do_seek (demux, pad, event);
} else {
res = aiurdemux_do_push_seek (demux, pad, event);
}
} else {
GST_DEBUG_OBJECT (demux,
"ignoring seek in push mode in current state");
res = FALSE;
}
gst_event_unref (event);
break;
case GST_EVENT_QOS:
case GST_EVENT_NAVIGATION:
res = FALSE;
gst_event_unref (event);
break;
default:
GST_LOG_OBJECT(demux,"gst_aiurdemux_handle_src_event event=%x",GST_EVENT_TYPE (event));
res = gst_pad_event_default (pad,parent, event);
break;
}
return res;
/* ERRORS */
not_support:
{
GST_WARNING ("Unsupport source event %s. ", GST_EVENT_TYPE_NAME (event));
gst_event_unref (event);
return FALSE;
}
}
static gboolean
gst_aiurdemux_handle_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
gboolean res = FALSE;
GstAiurDemux *demux = GST_AIURDEMUX (parent);
GST_LOG_OBJECT (pad, "%s query", GST_QUERY_TYPE_NAME (query));
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:{
GstFormat fmt;
gst_query_parse_duration (query, &fmt, NULL);
if (fmt == GST_FORMAT_TIME) {
gint64 duration = -1;
gst_aiurdemux_get_duration (demux, &duration);
if (duration > 0) {
gst_query_set_duration (query, GST_FORMAT_TIME, duration);
res = TRUE;
}
}
break;
}
case GST_QUERY_SEEKING:{
GstFormat fmt;
gboolean seekable = FALSE;
gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
if (fmt == GST_FORMAT_TIME) {
gint64 duration = -1;
gst_aiurdemux_get_duration (demux, &duration);
if (demux->seekable && aiurcontent_is_seelable(demux->content_info)) {
seekable = TRUE;
}
gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);
res = TRUE;
}
break;
}
case GST_QUERY_POSITION:
if (GST_CLOCK_TIME_IS_VALID (demux->segment.position)) {
gst_query_set_position (query, GST_FORMAT_TIME,
demux->segment.position);
res = TRUE;
}
break;
case GST_QUERY_SEGMENT:
{
GstFormat format;
gint64 start, stop = GST_CLOCK_TIME_NONE;
format = demux->segment.format;
start =
gst_segment_to_stream_time (&demux->segment, format,
demux->segment.start);
if (format == GST_FORMAT_TIME) {
gint64 duration = GST_CLOCK_TIME_NONE;
gst_aiurdemux_get_duration (demux, &duration);
if (duration > 0) {
stop = duration;
}
}
gst_query_set_segment (query, demux->segment.rate, format, start, stop);
res = TRUE;
break;
}
default:
GST_LOG_OBJECT(demux,"gst_aiurdemux_handle_src_query event=%x",GST_QUERY_TYPE (query));
res = gst_pad_query_default (pad, parent, query);
break;
}
return res;
}
static void
gst_aiurdemux_push_tags (GstAiurDemux * demux, AiurDemuxStream * stream)
{
if (G_LIKELY (stream->pad)) {
GST_DEBUG_OBJECT (demux, "Checking pad %s:%s for tags",
GST_DEBUG_PAD_NAME (stream->pad));
if (G_UNLIKELY (stream->pending_tags)) {
gst_pad_push_event (stream->pad,
gst_event_new_tag (stream->pending_tags));
stream->pending_tags = NULL;
}
if (G_UNLIKELY (stream->send_global_tags && demux->tag_list)) {
GST_DEBUG_OBJECT (demux, "Sending global tags %" GST_PTR_FORMAT,
demux->tag_list);
gst_pad_push_event (stream->pad,
gst_event_new_tag (gst_tag_list_ref (demux->tag_list)));
stream->send_global_tags = FALSE;
}
}
}
/* push event on all source pads; takes ownership of the event */
static void
gst_aiurdemux_push_event (GstAiurDemux * demux, GstEvent * event)
{
gint n;
//gboolean pushed_sucessfully = FALSE;
for (n = 0; n < demux->n_streams; n++) {
GstPad *pad = demux->streams[n]->pad;
if (pad) {
if (gst_pad_push_event (pad, gst_event_ref (event))) {
;//pushed_sucessfully = TRUE;
}
}
}
gst_event_unref (event);
}
static GstPadTemplate *
gst_aiurdemux_sink_pad_template (void)
{
static GstPadTemplate *templ = NULL;
if (!templ) {
GstCaps *caps = aiur_core_get_caps ();
if (caps) {
templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps);
gst_caps_unref (caps);
}
}
return templ;
}
static gboolean aiurdemux_sink_activate (GstPad * sinkpad,GstObject * parent)
{
GstQuery *query;
gboolean pull_mode;
query = gst_query_new_scheduling ();
if (!gst_pad_peer_query (sinkpad, query)) {
gst_query_unref (query);
goto activate_push;
}
pull_mode = gst_query_has_scheduling_mode_with_flags (query,
GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
gst_query_unref (query);
if (!pull_mode)
goto activate_push;
GST_LOG_OBJECT (sinkpad, "activating pull");
return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
activate_push:
GST_LOG_OBJECT (sinkpad, "activating push");
return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
}
static gboolean aiurdemux_sink_activate_mode (GstPad * sinkpad,
GstObject * parent, GstPadMode mode, gboolean active)
{
gboolean res = FALSE;
switch (mode) {
case GST_PAD_MODE_PUSH:
return aiurdemux_sink_activate_push(sinkpad, parent, active);
case GST_PAD_MODE_PULL:
return aiurdemux_sink_activate_pull(sinkpad, parent, active);
default:
break;
}
return res;
}
static gboolean aiurdemux_sink_activate_pull (GstPad * sinkpad, GstObject * parent, gboolean active)
{
GstAiurDemux *demux = GST_AIURDEMUX (parent);
if (active) {
demux->pullbased = TRUE;
return gst_pad_start_task (sinkpad,
(GstTaskFunction) aiurdemux_pull_task, sinkpad, NULL);
} else {
return gst_pad_stop_task (sinkpad);
}
}
gpointer aiurdemux_loop_push (gpointer * data)
{
GstAiurDemux *demux = (GstAiurDemux *) data;
g_mutex_lock (&demux->runmutex);
while (demux->loop_push) {
aiurdemux_push_task (demux);
}
g_mutex_unlock (&demux->runmutex);
return NULL;
}
static gboolean aiurdemux_sink_activate_push (GstPad * sinkpad, GstObject * parent, gboolean active)
{
GstAiurDemux *demux = GST_AIURDEMUX (parent);
demux->pullbased = FALSE;
if (active) {
demux->loop_push = TRUE;
demux->thread = g_thread_new ("aiur_push",(GThreadFunc) aiurdemux_loop_push, (gpointer) demux);
return TRUE;
} else {
demux->loop_push = FALSE;
gst_aiur_stream_cache_close (demux->stream_cache);
/* make sure task is closed */
g_mutex_lock (&demux->runmutex);
g_mutex_unlock (&demux->runmutex);
if (demux->thread) {
g_thread_unref(demux->thread);
demux->thread = NULL;
}
return gst_pad_stop_task (sinkpad);
}
}
static void aiurdemux_pull_task (GstPad * pad)
{
GstAiurDemux *demux;
GstFlowReturn ret = GST_FLOW_OK;
demux = GST_AIURDEMUX (gst_pad_get_parent (pad));
switch (demux->state) {
case AIURDEMUX_STATE_PROBE:
ret = aiurdemux_loop_state_probe (demux);
break;
case AIURDEMUX_STATE_INITIAL:
ret = aiurdemux_loop_state_init (demux);
break;
case AIURDEMUX_STATE_HEADER:
ret = aiurdemux_loop_state_header (demux);
break;
case AIURDEMUX_STATE_MOVIE:
ret = aiurdemux_loop_state_movie (demux);
break;
default:
/* ouch */
goto invalid_state;
}
/* if something went wrong, pause */
if (ret != GST_FLOW_OK)
goto pause;
done:
gst_object_unref (demux);
return;
invalid_state:
aiurdemux_send_stream_eos_all (demux);
pause:
{
const gchar *reason = gst_flow_get_name (ret);
GST_WARNING ("pausing task, reason %s \r\n", reason);
gst_pad_pause_task (pad);
if (ret < GST_FLOW_EOS) {
GST_ELEMENT_ERROR (demux, STREAM, FAILED,
(NULL), ("streaming stopped, reason %s, state %d",
reason, demux->state));
}
goto done;
}
}
static void aiurdemux_push_task (GstAiurDemux * demux)
{
GstFlowReturn ret = GST_FLOW_OK;
switch (demux->state) {
case AIURDEMUX_STATE_PROBE:
ret = aiurdemux_loop_state_probe (demux);
break;
case AIURDEMUX_STATE_INITIAL:
ret = aiurdemux_loop_state_init (demux);
break;
case AIURDEMUX_STATE_HEADER:
ret = aiurdemux_loop_state_header (demux);
break;
case AIURDEMUX_STATE_MOVIE:
ret = aiurdemux_loop_state_movie (demux);
break;
default:
/* ouch */
goto invalid_state;
}
/* if something went wrong, pause */
if (ret != GST_FLOW_OK)
goto pause;
done:
return;
invalid_state:
aiurdemux_send_stream_eos_all (demux);
pause:
{
const gchar *reason = gst_flow_get_name (ret);
GST_LOG_OBJECT (demux, "pausing task, reason %s \r\n", reason);
demux->loop_push = FALSE;
if (ret < GST_FLOW_EOS) {
GST_ELEMENT_ERROR (demux, STREAM, FAILED,
(NULL), ("streaming stopped, reason %s, state %d",
reason, demux->state));
}
goto done;
}
}
static gboolean gst_aiurdemux_setcaps(GstPad * pad, GstObject * parent, GstCaps * caps)
{
GstAiurDemux *demux = GST_AIURDEMUX (parent);
if (!demux->pullbased)
gst_aiur_stream_cache_attach_pad (demux->stream_cache, pad);
GST_DEBUG_OBJECT(demux,"gst_aiurdemux_setcaps=%s",gst_caps_to_string(caps));
if(demux->core_interface == NULL){
demux->core_interface = aiur_core_create_interface_from_caps (caps);
}else{
return TRUE;
}
if ((demux->core_interface) && (demux->core_interface->name)
&& (demux->core_interface->name)) {
gst_tag_list_add (demux->tag_list, GST_TAG_MERGE_REPLACE,
GST_TAG_CONTAINER_FORMAT, (demux->core_interface->name), NULL);
GST_INFO_OBJECT (demux, "Container: %s", demux->core_interface->name);
}
if (demux->core_interface) {
demux->state = AIURDEMUX_STATE_INITIAL;
return TRUE;
} else{
return FALSE;
}
}
static GstFlowReturn
aiurdemux_loop_state_probe (GstAiurDemux * demux)
{
GstBuffer *buffer = NULL;
GstFlowReturn ret = GST_FLOW_OK;
GstCaps * caps;
if (demux->pullbased) {
gst_pad_pull_range (demux->sinkpad, (guint64) 0,
AIURDEMUX_INIT_BLOCK_SIZE, &buffer);
gst_buffer_unref (buffer);
caps = gst_pad_peer_query_caps (demux->sinkpad, NULL);
GST_LOG_OBJECT(demux,"state_probe CAPS=%s",gst_caps_to_string(caps));
gst_aiurdemux_setcaps(demux->sinkpad,(GstObject*) demux, caps);
gst_caps_unref (caps);
}
return ret;
}
static GstFlowReturn
aiurdemux_loop_state_init (GstAiurDemux * demux)
{
GstFlowReturn ret = GST_FLOW_ERROR;
int32 parser_result = PARSER_SUCCESS;
FslParserHandle core_handle=NULL;
gboolean isLive = FALSE;
AiurCoreInterface *IParser = demux->core_interface;
FslFileStream *file_cbks;
ParserMemoryOps *mem_cbks;
ParserOutputBufferOps *buf_cbks;
uint32 flag;
if (IParser == NULL)
return GST_FLOW_OK;
file_cbks = g_new0 (FslFileStream, 1);
mem_cbks = g_new0 (ParserMemoryOps, 1);
buf_cbks = g_new0 (ParserOutputBufferOps, 1);
if ((!file_cbks) || (!mem_cbks) || (!buf_cbks))
goto fail;
if(!demux->content_info)
goto fail;
if(demux->pullbased)
aiurcontent_get_pullfile_callback(demux->content_info,file_cbks);
else
aiurcontent_get_pushfile_callback(demux->content_info,file_cbks);
aiurcontent_get_memory_callback(demux->content_info,mem_cbks);
aiurcontent_get_buffer_callback(demux->content_info,buf_cbks);
aiurcontent_init(demux->content_info,demux->sinkpad,demux->stream_cache);
isLive = aiurcontent_is_live(demux->content_info);
if(IParser->createParser2){
flag = FLAG_H264_NO_CONVERT;
if(isLive){
flag |= FILE_FLAG_NON_SEEKABLE;
flag |= FILE_FLAG_READ_IN_SEQUENCE;
}
parser_result = IParser->createParser2(flag ,file_cbks, mem_cbks,
buf_cbks, (void *)(demux->content_info), &core_handle);
}else{
parser_result = IParser->createParser((bool)isLive,file_cbks, mem_cbks,
buf_cbks, (void *)(demux->content_info), &core_handle);
}
if (parser_result != PARSER_SUCCESS) {
GST_ERROR_OBJECT(demux,"Failed to create fsl parser! ret=%d",parser_result);
goto fail;
}
demux->core_handle = core_handle;
demux->state = AIURDEMUX_STATE_HEADER;
ret = GST_FLOW_OK;
g_free (file_cbks);
g_free (mem_cbks);
g_free (buf_cbks);
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_init SUCCESS");
return ret;
fail:
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_init FAIL");
if (file_cbks) {
g_free (file_cbks);
}
if (mem_cbks) {
g_free (mem_cbks);
}
if (buf_cbks) {
g_free (buf_cbks);
}
if (core_handle) {
IParser->deleteParser(core_handle);
}
return ret;
}
static GstFlowReturn aiurdemux_loop_state_header (GstAiurDemux * demux)
{
GstFlowReturn ret = GST_FLOW_ERROR;
int32 parser_result = PARSER_SUCCESS;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
uint64 start_time_us = 0;
int32 i = 0;
uint64 duration = 0;
gboolean need_init_index = TRUE;
gchar * index_file = NULL;
do{
if(IParser == NULL || handle == NULL)
break;
index_file = aiurcontent_get_index_file(demux->content_info);
if ((demux->option.index_enabled) && index_file) {
AiurIndexTable *idxtable =
aiurdemux_import_idx_table (index_file);
if (idxtable) {
if ((idxtable->coreid) && (IParser->coreid)
&& (strlen (IParser->coreid) == idxtable->coreid_len)
&& (!memcmp (idxtable->coreid, IParser->coreid, idxtable->coreid_len))) {
if ((IParser->initializeIndex)
&& (IParser->importIndex)
&& (idxtable->info.size)) {
parser_result = IParser->importIndex(handle, idxtable->idx,
idxtable->info.size);
if (parser_result == PARSER_SUCCESS) {
GST_INFO ("Index table %s[size %d] imported.",
index_file, idxtable->info.size);
need_init_index = FALSE;
}
}
}
aiurdemux_destroy_idx_table (idxtable);
}
}
if (need_init_index && IParser->initializeIndex != NULL) {
parser_result = IParser->initializeIndex(handle);
}
parser_result = IParser->isSeekable(handle, &demux->seekable);
if(parser_result != PARSER_SUCCESS)
break;
demux->movie_duration = GST_CLOCK_TIME_NONE;
parser_result = IParser->getMovieDuration(handle,&duration);
demux->movie_duration = AIUR_CORETS_2_GSTTS (duration);
if(parser_result != PARSER_SUCCESS)
break;
if(aiurdemux_set_readmode(demux) == FALSE)
break;
parser_result = IParser->getNumTracks(handle,&demux->track_count);
if(parser_result != PARSER_SUCCESS)
break;
//get progreme number and parse programes
if(IParser->getNumPrograms)
IParser->getNumPrograms(handle, &demux->program_num);
if(demux->program_num > 0){
demux->programs = g_new0 (AiurDemuxProgram*, demux->program_num);
aiurdemux_parse_programs (demux);
}
demux->tag_list = aiurdemux_add_user_tags (demux);
//parse stream and tracks
parser_result = aiurdemux_parse_streams (demux);
gst_element_no_more_pads (GST_ELEMENT_CAST (demux));
for (i = 0; i < demux->n_streams; i++) {
IParser->seek(handle,i,&start_time_us,SEEK_FLAG_NO_LATER);
}
if (parser_result == PARSER_SUCCESS && demux->n_streams > 0) {
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_header next MOVIE");
demux->state = AIURDEMUX_STATE_MOVIE;
ret = GST_FLOW_OK;
}
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_header SUCCESS");
}while(0);
if(ret != GST_FLOW_OK){
aiurdemux_release_resource (demux);
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_header FAILED");
}
return ret;
}
static GstFlowReturn aiurdemux_loop_state_movie (GstAiurDemux * demux)
{
GstFlowReturn ret = GST_FLOW_OK;
AiurDemuxStream *stream = NULL;
GstBuffer *gstbuf = NULL;
uint32 track_idx = 0;
AiurCoreInterface *IParser = demux->core_interface;
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_movie BEGIN");
if (demux->pending_event) {
aiurdemux_send_pending_events (demux);
demux->pending_event = FALSE;
if (demux->valid_mask == 0) {
return GST_FLOW_EOS;
}
}
//select a track to read
track_idx = aiurdemux_choose_next_stream(demux);
//check long interleave for file mode
if(demux->read_mode == PARSER_READ_MODE_FILE_BASED){
aiurdemux_check_interleave_stream_eos(demux);
stream = aiurdemux_trackidx_to_stream (demux, track_idx);
//push buffer from interleave queue
if ((stream->buf_queue)
&& (!g_queue_is_empty (stream->buf_queue))) {
gstbuf = g_queue_pop_head (stream->buf_queue);
stream->buf_queue_size -= gst_buffer_get_size(gstbuf);//GST_BUFFER_SIZE (gstbuf);
ret = aiurdemux_push_pad_buffer (demux, stream, gstbuf);
goto bail;
}
}
//read stream buffer
ret = aiurdemux_read_buffer(demux,&track_idx,&stream);
GST_LOG_OBJECT(demux,"aiurdemux_loop_state_movie read buffer ret=%d",ret);
if(ret != GST_FLOW_OK)
goto beach;
//update time
if (!stream || !stream->buffer)
goto bail;
GST_LOG_OBJECT (demux, "CHECK track_idx=%d,usStartTime=%lld,sampleFlags=%x",track_idx,stream->sample_stat.start,stream->sample_stat.flag);
if((demux->seekable == FALSE)
&& !aiurcontent_is_seelable(demux->content_info)
&& !aiurcontent_is_random_access(demux->content_info))
aiurdemux_check_start_offset(demux, stream);
aiurdemux_adjust_timestamp (demux, stream, stream->buffer);
//send new segment
if (stream->new_segment) {
GST_BUFFER_FLAG_UNSET (stream->buffer, GST_BUFFER_FLAG_DELTA_UNIT);
GST_BUFFER_FLAG_SET (stream->buffer, GST_BUFFER_FLAG_DISCONT);
aiurdemux_send_stream_newsegment (demux, stream);
}
gst_aiurdemux_push_tags (demux, stream);
//for vorbis codec data
if(demux->option.disable_vorbis_codec_data &&
(stream->type == MEDIA_AUDIO)
&& (stream->codec_type == AUDIO_VORBIS)
&& (stream->send_codec_data == FALSE)
&& (stream->codec_data.length)){
aiurdemux_parse_vorbis_codec_data(demux, stream);
stream->send_codec_data = TRUE;
}
//push buffer to pad
if (demux->interleave_queue_size) {
stream->buf_queue_size += gst_buffer_get_size(stream->buffer);
if (stream->buf_queue_size > stream->buf_queue_size_max) {
stream->buf_queue_size_max = stream->buf_queue_size;
}
g_queue_push_tail (stream->buf_queue, stream->buffer);
stream->buffer = NULL;
} else {
ret = aiurdemux_push_pad_buffer (demux, stream, stream->buffer);
stream->buffer = NULL;
}
AIUR_RESET_SAMPLE_STAT (stream->sample_stat);
ret = aiurdemux_combine_flows (demux, stream, ret);
GST_LOG_OBJECT (demux, "STATE MOVIE END ret=%d",ret);
bail:
return ret;
beach:
if (stream) {
if (stream->buffer) {
gst_buffer_unref (stream->buffer);
stream->buffer = NULL;
}
gst_adapter_clear (stream->adapter);
AIUR_RESET_SAMPLE_STAT (stream->sample_stat);
}
return ret;
}
static void
aiurdemux_print_track_info (AiurDemuxStream * stream)
{
if (NULL == stream)
return;
if ((stream->pad) && (stream->caps)) {
gchar *mime = gst_caps_to_string (stream->caps);
gchar *padname = gst_pad_get_name (stream->pad);
g_print("------------------------\n");
g_print (" Track %02d [%s] Enabled\n", stream->track_idx,
padname ? padname : "");
g_print ("\tDuration: %" GST_TIME_FORMAT "\n",
GST_TIME_ARGS (stream->track_duration));
g_print ("\tLanguage: %s\n", stream->lang);
if (mime) {
g_print (" Mime:\n\t%s \r\n", mime);
g_free (mime);
}
if (padname) {
g_free (padname);
}
} else {
g_print (" Track %02d [%s]: Disabled\n", stream->track_idx,
AIUR_MEDIATYPE2STR (stream->type));
g_print ("\tCodec: %ld, SubCodec: %ld\n",
stream->codec_type, stream->codec_sub_type);
}
g_print("------------------------\n");
}
static gboolean aiurdemux_set_readmode (GstAiurDemux * demux)
{
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
gchar *format = NULL;
demux->isMPEG = FALSE;
int32 parser_result;
uint32 readmode;
gboolean ret = gst_tag_list_get_string (demux->tag_list, GST_TAG_CONTAINER_FORMAT, &format);
if(ret && format && strncmp(format,"MPEG",4) == 0){
demux->isMPEG = TRUE;
}
if(format ){
g_free(format);
format = NULL;
}
//use track mode for local file and file mode for streaming file.
if(aiurcontent_is_random_access(demux->content_info) && !demux->isMPEG){
readmode = PARSER_READ_MODE_TRACK_BASED;
}else{
readmode = PARSER_READ_MODE_FILE_BASED;
}
do{
parser_result = IParser->setReadMode(handle, readmode);
if (parser_result != PARSER_SUCCESS) {
//some parser does not have track mode API, so use file mode.
readmode = PARSER_READ_MODE_FILE_BASED;
parser_result = IParser->setReadMode(handle, readmode);
if (parser_result != PARSER_SUCCESS)
break;
}
//check readmode API
if ((readmode == PARSER_READ_MODE_TRACK_BASED) && (IParser->getNextSample == NULL))
break;
if((readmode == PARSER_READ_MODE_FILE_BASED) && (IParser->getFileNextSample == NULL))
break;
demux->read_mode = readmode;
if (readmode == PARSER_READ_MODE_FILE_BASED &&
!(demux->isMPEG && aiurcontent_is_live(demux->content_info))){
demux->interleave_queue_size = demux->option.interleave_queue_size;
GST_DEBUG_OBJECT(demux,"read mode = file mode");
} else {
demux->interleave_queue_size = 0;
GST_DEBUG_OBJECT(demux,"read mode = track mode");
}
return TRUE;
}while(0);
return FALSE;
}
static gboolean
aiurdemux_parse_programs (GstAiurDemux * demux)
{
gboolean ret = FALSE;
if ((aiurdemux_parse_pmt (demux))
|| (aiurdemux_parse_program_info (demux))) {
aiurdemux_select_programs (demux);
ret = TRUE;
}
return ret;
}
static gboolean
aiurdemux_parse_pmt (GstAiurDemux * demux)
{
gboolean ret = FALSE;
int32 core_ret = PARSER_SUCCESS;
//AiurDemuxClipInfo *clip_info = &demux->clip_info;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
UserDataID id = USER_DATA_PMT;
UserDataFormat format = USER_DATA_FORMAT_PMT_INFO;
PMTInfoList *pmt = NULL;
uint32 userDataSize = 0;
core_ret = IParser->getMetaData(handle,id, &format, (uint8 **) & pmt, &userDataSize);
if ((core_ret == PARSER_SUCCESS) && (pmt != NULL)
&& (userDataSize > 0)) {
int n;
for (n = 0;
((n < demux->program_num) && (n < pmt->m_dwProgramNum)); n++) {
AiurDemuxProgram *program;
PMTInfo *pmtinfo = &pmt->m_ptPMTInfo[n];
program = g_try_malloc (sizeof (AiurDemuxProgram) +
sizeof (AiurDemuxProgramTrack) * pmtinfo->m_dwTrackNum);
if (program) {
int m;
program->program_number = pmtinfo->m_dwChannel;
program->enabled = FALSE;
program->pid = pmtinfo->m_dwPID;
program->track_num = pmtinfo->m_dwTrackNum;
for (m = 0; m < program->track_num; m++) {
program->tracks[m].id = pmtinfo->m_ptTrackInfo[m].m_dwTrackNo;
program->tracks[m].pid = pmtinfo->m_ptTrackInfo[m].m_dwPID;
memcpy (program->tracks[m].lang,
pmtinfo->m_ptTrackInfo[m].m_byLan, 3);
}
demux->programs[n] = program;
}
}
ret = TRUE;
}
return ret;
}
gboolean
aiurdemux_parse_program_info (GstAiurDemux * demux)
{
gboolean ret = FALSE;
int32 core_ret = PARSER_SUCCESS;
//AiurDemuxClipInfo *clip_info = &demux->clip_info;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
UserDataID id = USER_DATA_PROGRAMINFO;
UserDataFormat format = USER_DATA_FORMAT_PROGRAM_INFO;
ProgramInfoMenu *pinfo = NULL;
uint32 userDataSize = 0;
int n;
core_ret = IParser->getMetaData(handle, id, &format, (uint8 **) & pinfo, &userDataSize);
if ((core_ret != PARSER_SUCCESS) || (userDataSize == 0)) {
pinfo = NULL;
}
for (n = 0; n < demux->program_num; n++) {
AiurDemuxProgram *program;
uint32 track_num, *tracklist;
core_ret = IParser->getProgramTracks(handle, n,
&track_num, &tracklist);
if (core_ret == PARSER_SUCCESS) {
program =
g_try_malloc (sizeof (AiurDemuxProgram) +
sizeof (AiurDemuxProgramTrack) * track_num);
if (program) {
int m;
program->enabled = FALSE;
if ((pinfo) && (n < pinfo->m_dwProgramNum)) {
program->program_number = pinfo->m_atProgramInfo[n].m_dwChannel;
program->pid = pinfo->m_atProgramInfo[n].m_dwPID;
} else {
program->program_number = -1;
program->pid = -1;
}
program->track_num = track_num;
for (m = 0; m < track_num; m++) {
program->tracks[m].pid = -1;
program->tracks[m].id = tracklist[m];
program->tracks[m].lang[0] = '\0';
}
demux->programs[n] = program;
}
}
}
ret = TRUE;
return ret;
}
static void
aiurdemux_select_programs (GstAiurDemux * demux)
{
int n;
for (n = 0; n < demux->program_num; n++) {
AiurDemuxProgram *program;
program = demux->programs[n];
if (program) {
if (demux->option.multiprogram_enabled) {
if (((demux->option.program_mask == 0))
|| ((1 << n) & demux->option.program_mask)) {
program->enabled = TRUE;
}
} else {
if (demux->option.program_number >= 0) {
if (demux->option.program_number == program->program_number) {
program->enabled = TRUE;
break;
}
} else {
program->enabled = TRUE;
break;
}
}
}
}
}
static GstTagList *
aiurdemux_add_user_tags (GstAiurDemux * demux)
{
int32 core_ret = 0;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
GstTagList *list = demux->tag_list;
int i;
if (list == NULL)
return list;
if (IParser->getMetaData) {
UserDataID id;
UserDataFormat format;
for (i = 0; i < G_N_ELEMENTS (g_user_data_entry); i++) {
uint8 *userData = NULL;
uint32 userDataSize = 0;
id = g_user_data_entry[i].core_tag;
format = g_user_data_entry[i].format;
core_ret = IParser->getMetaData(handle,id, &format, &userData, &userDataSize);
if ((core_ret == PARSER_SUCCESS) &&
(userData != NULL) && (userDataSize > 0)) {
if (USER_DATA_FORMAT_UTF8 == format) {
GString *string = g_string_new_len ((const gchar *)userData, userDataSize);
if (string) {
/* FIXME : create GDate object for GST_TAG_DATA */
if (USER_DATA_CREATION_DATE == id) {
guint y, m = 1, d = 1;
gint ret;
ret = sscanf (string->str, "%u-%u-%u", &y, &m, &d);
if (ret >= 1 && y > 1500 && y < 3000) {
GDate *date;
date = g_date_new_dmy (d, m, y);
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, g_user_data_entry[i].gst_tag_name,
date, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, string->str);
g_date_free (date);
}
g_string_free (string, TRUE);
continue;
}else if(USER_DATA_LOCATION == id){
gdouble latitude;
gdouble longitude;
guint longitude_pos = 0;
guint8* latitude_ptr = g_strndup ((gchar *) userData, 8);
guint8* longitude_ptr = g_strndup ((gchar *) userData+8, 9);
if ((sscanf (latitude_ptr, "%lf", &latitude) == 1)
&& (sscanf (longitude_ptr, "%lf", &longitude) == 1)) {
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
GST_TAG_GEO_LOCATION_LATITUDE, latitude, NULL);
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
GST_TAG_GEO_LOCATION_LONGITUDE, longitude, NULL);
GST_INFO_OBJECT (demux, "LATITUDE=%lf,LONGITUDE=%lf", latitude,longitude);
}
g_free (latitude_ptr);
g_free (longitude_ptr);
g_string_free (string, TRUE);
continue;
}else if(USER_DATA_TRACKNUMBER == id || USER_DATA_TOTALTRACKNUMBER == id || USER_DATA_DISCNUMBER == id ){
guint32 value;
value = atoi(string->str);
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
g_user_data_entry[i].gst_tag_name, value, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, string->str);
g_string_free (string, TRUE);
continue;
}else if (USER_DATA_RATING ==id) {
double value;
value = atof(string->str);
if (value <= 5.0)
value = value*20;
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
g_user_data_entry[i].gst_tag_name, (guint32)value, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, string->str);
g_string_free (string, TRUE);
continue;
}
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
g_user_data_entry[i].gst_tag_name, string->str, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, string->str);
g_string_free (string, TRUE);
}
} else if ((USER_DATA_FORMAT_JPEG == format) ||
(USER_DATA_FORMAT_PNG == format) ||
(USER_DATA_FORMAT_BMP == format) ||
(USER_DATA_FORMAT_GIF == format)) {
GstSample *sample = gst_tag_image_data_to_image_sample (userData,
userDataSize, GST_TAG_IMAGE_TYPE_UNDEFINED);
if (sample) {
gst_tag_list_add (list, GST_TAG_MERGE_APPEND,
g_user_data_entry[i].gst_tag_name, sample, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, format,userDataSize);
gst_sample_unref (sample);
}
}
}
}
} else if (IParser->getUserData) {
for (i = 0; i < G_N_ELEMENTS (g_user_data_entry); i++) {
uint16 *userData = NULL;
uint32 userDataSize = 0;
core_ret = IParser->getUserData(handle,g_user_data_entry[i].core_tag, &userData, &userDataSize);
if (core_ret == PARSER_SUCCESS) {
if ((userData) && (userDataSize)) {
gsize in, out;
gchar *value_utf8;
value_utf8 =
g_convert ((const char *) userData, userDataSize * 2, "UTF-8",
"UTF-16LE", &in, &out, NULL);
if (value_utf8) {
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
g_user_data_entry[i].gst_tag_name, value_utf8, NULL);
GST_INFO_OBJECT (demux, g_user_data_entry[i].print_string, value_utf8);
g_free (value_utf8);
}
}
}
}
}
if (gst_tag_list_is_empty (list)) {
gst_tag_list_unref (list);
list = NULL;
}
return list;
}
static int aiurdemux_parse_streams (GstAiurDemux * demux)
{
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
int ret = PARSER_SUCCESS;
uint32 i = 0;
AiurDemuxStream *stream = NULL;
demux->n_streams = 0;
demux->n_video_streams = 0;
demux->n_audio_streams = 0;
demux->n_sub_streams = 0;
demux->sub_read_cnt = 0;
demux->sub_read_ready = 0;
memset(demux->streams, 0,GST_AIURDEMUX_MAX_STREAMS*sizeof(AiurDemuxStream *));
for(i = 0; i < demux->track_count; i++){
uint64 duration = 0;
stream = g_new0 (AiurDemuxStream, 1);
if(stream == NULL){
ret = PARSER_INSUFFICIENT_MEMORY;
break;
}
memset(stream, 0, sizeof(AiurDemuxStream));
stream->pid = -1;
stream->track_idx = i;
stream->partial_sample = FALSE;
ret = IParser->getTrackType(handle, i, &stream->type,
&stream->codec_type, &stream->codec_sub_type);
if(ret != PARSER_SUCCESS)
break;
ret = IParser->getTrackDuration(handle, i, &duration);
if(ret != PARSER_SUCCESS)
break;
stream->track_duration = AIUR_CORETS_2_GSTTS(duration);
if(IParser->getLanguage){
ret = IParser->getLanguage(handle, i, (uint8 *)stream->lang);
if(ret != PARSER_SUCCESS){
stream->lang[0] = '\0';
}
}
ret = IParser->getBitRate(handle, i, &stream->bitrate);
if (ret != PARSER_SUCCESS) {
stream->bitrate = 0;
}
ret = IParser->getDecoderSpecificInfo(handle, i,
&stream->codec_data.codec_data, &stream->codec_data.length);
ret = PARSER_SUCCESS;
int m, n;
gboolean track_enable = TRUE;
for (m = 0; m < demux->program_num; m++) {
if (demux->programs[m]) {
for (n = 0; n < demux->programs[m]->track_num; n++) {
if (demux->programs[m]->tracks[n].id == stream->track_idx
&& demux->programs[m]->enabled == FALSE) {
track_enable = FALSE;
break;
}
}
}
if (track_enable == FALSE)
break;
}
if (track_enable == FALSE)
continue;
switch (stream->type) {
case MEDIA_VIDEO:
aiurdemux_parse_video (demux, stream, i);
break;
case MEDIA_AUDIO:
aiurdemux_parse_audio (demux, stream, i);
break;
case MEDIA_TEXT:
aiurdemux_parse_text (demux, stream, i);
break;
default:
break;
}
if ((stream->send_codec_data) && (stream->codec_data.length)
&& (stream->codec_data.length < AIURDEMUX_CODEC_DATA_MAX_LEN)) {
GstBuffer *gstbuf;
gstbuf = gst_buffer_new_and_alloc (stream->codec_data.length);
gst_buffer_fill(gstbuf,0,(guint8 *)stream->codec_data.codec_data,stream->codec_data.length);
GST_DEBUG_OBJECT(demux,"set codec data for caps len=%d",stream->codec_data.length);
if(stream->caps){
gst_caps_set_simple (stream->caps, "codec_data",
GST_TYPE_BUFFER, gstbuf, NULL);
}
gst_buffer_unref (gstbuf);
}
aiurdemux_print_track_info (stream);
if (stream->pad) {
//gboolean padRet = TRUE;
gchar *stream_id;
GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream;
gst_pad_use_fixed_caps (stream->pad);
gst_pad_set_event_function (stream->pad, gst_aiurdemux_handle_src_event);
gst_pad_set_query_function (stream->pad, gst_aiurdemux_handle_src_query);
gst_pad_set_active (stream->pad, TRUE);
ret = IParser->enableTrack(handle, stream->track_idx, TRUE);
if(ret != PARSER_SUCCESS)
break;
stream_id =
gst_pad_create_stream_id_printf (stream->pad,
GST_ELEMENT_CAST (demux), "%u", stream->track_idx);
gst_pad_push_event (stream->pad, gst_event_new_stream_start (stream_id));
g_free (stream_id);
gst_pad_set_caps (stream->pad, stream->caps);
GST_INFO_OBJECT (demux, "adding pad %s %p to demux %p, caps string=%s",
GST_OBJECT_NAME (stream->pad), stream->pad, demux,gst_caps_to_string(stream->caps));
gst_element_add_pad (GST_ELEMENT_CAST (demux), stream->pad);
// global tags go on each pad anyway
stream->send_global_tags = TRUE;
stream->mask = (1 << demux->n_streams);
stream->adapter = gst_adapter_new ();
aiurdemux_reset_stream (demux, stream);
if (demux->interleave_queue_size) {
stream->buf_queue = g_queue_new ();
}
demux->streams[demux->n_streams] = stream;
demux->n_streams++;
stream->discont = TRUE;
}else{
IParser->enableTrack(handle, i, FALSE);
if (stream) {
if (stream->caps) {
gst_caps_unref (stream->caps);
}
if (stream->pending_tags) {
gst_tag_list_unref (stream->pending_tags);
}
g_free (stream);
}
}
}
if(ret != PARSER_SUCCESS){
for (; i < demux->track_count; i++) {
IParser->enableTrack(handle, i, FALSE);
}
}
GST_LOG_OBJECT(demux,"aiurdemux_parse_streams ret=%d",ret);
return ret;
}
static void aiurdemux_parse_video (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index)
{
gchar *mime = NULL, *codec = NULL;
gchar *padname;
int32 parser_ret = PARSER_SUCCESS;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
AiurdemuxCodecStruct * codec_struct = NULL;
int i;
memset(&stream->info.video, 0, sizeof(AiurDemuxVideoInfo));
parser_ret = IParser->getVideoFrameWidth(handle,track_index,&stream->info.video.width);
if(parser_ret != PARSER_SUCCESS)
goto bail;
parser_ret = IParser->getVideoFrameHeight(handle,track_index,&stream->info.video.height);
if(parser_ret != PARSER_SUCCESS)
goto bail;
parser_ret = IParser->getVideoFrameRate(handle,track_index,&stream->info.video.fps_n,
&stream->info.video.fps_d);
if(parser_ret != PARSER_SUCCESS)
goto bail;
if ((stream->info.video.fps_n == 0) || (stream->info.video.fps_d == 0)
|| (stream->info.video.fps_n /stream->info.video.fps_d) > 250) {
stream->info.video.fps_n = AIURDEMUX_FRAME_N_DEFAULT;
stream->info.video.fps_d = AIURDEMUX_FRAME_D_DEFAULT;
}
if ((stream->info.video.width == 0) || (stream->info.video.height == 0)) {
stream->info.video.width = AIURDEMUX_VIDEO_WIDTH_DEFAULT;
stream->info.video.height = AIURDEMUX_VIDEO_HEIGHT_DEFAULT;
}
stream->send_codec_data = TRUE;
for(i = 0; i < sizeof(aiurdemux_videocodec_tab)/sizeof(AiurdemuxCodecStruct); i++){
codec_struct = &aiurdemux_videocodec_tab[i];
if (stream->codec_type == codec_struct->type){
if((codec_struct->subtype > 0) && (stream->codec_sub_type == codec_struct->subtype)){
mime = (gchar *)codec_struct->mime;
codec = (gchar *)codec_struct->codec_str;
break;
}else if(codec_struct->subtype == 0){
mime = (gchar *)codec_struct->mime;
codec = (gchar *)codec_struct->codec_str;
break;
}
}
}
if(mime == NULL)
goto bail;
if(stream->codec_type == VIDEO_H264){
if(stream->codec_data.length > 0 && stream->codec_data.codec_data != NULL){
mime = g_strdup_printf
("%s, stream-format=(string)avc, width=(int)%ld, height=(int)%ld, framerate=(fraction)%ld/%ld",
mime, stream->info.video.width, stream->info.video.height,
stream->info.video.fps_n, stream->info.video.fps_d);
stream->send_codec_data = TRUE;
}else{
mime =
g_strdup_printf
("%s, stream-format=(string)byte-stream, width=(int)%ld, height=(int)%ld, framerate=(fraction)%ld/%ld",
mime, stream->info.video.width, stream->info.video.height,
stream->info.video.fps_n, stream->info.video.fps_d);
stream->send_codec_data = FALSE;
}
}else if (stream->codec_type == VIDEO_HEVC){
if(stream->codec_data.length > 0 && stream->codec_data.codec_data != NULL){
mime = g_strdup_printf
("%s, stream-format=(string)hev1, width=(int)%ld, height=(int)%ld, framerate=(fraction)%ld/%ld",
mime, stream->info.video.width, stream->info.video.height,
stream->info.video.fps_n, stream->info.video.fps_d);
stream->send_codec_data = TRUE;
}else{
mime =
g_strdup_printf
("%s, stream-format=(string)byte-stream, width=(int)%ld, height=(int)%ld, framerate=(fraction)%ld/%ld",
mime, stream->info.video.width, stream->info.video.height,
stream->info.video.fps_n, stream->info.video.fps_d);
stream->send_codec_data = FALSE;
}
}else{
mime =
g_strdup_printf
("%s, width=(int)%ld, height=(int)%ld, framerate=(fraction)%ld/%ld",
mime, stream->info.video.width, stream->info.video.height,
stream->info.video.fps_n, stream->info.video.fps_d);
}
stream->caps = gst_caps_from_string (mime);
g_free (mime);
if (stream->pid < 0) {
stream->pid = demux->n_video_streams;
}
padname = g_strdup_printf ("video_%u", stream->pid);
GST_INFO ("Create video pad %s \r\n", padname);
stream->pad =
gst_pad_new_from_static_template (&gst_aiurdemux_videosrc_template,
padname);
g_free (padname);
demux->n_video_streams++;
stream->pending_tags = gst_tag_list_new (GST_TAG_CODEC, codec, NULL);
if (stream->lang[0] != '\0') {
gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
GST_TAG_LANGUAGE_CODE, stream->lang, NULL);
}
if (stream->bitrate) {
gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, stream->bitrate, NULL);
}
if (demux->tag_list) {
gst_tag_list_add (demux->tag_list, GST_TAG_MERGE_REPLACE, GST_TAG_VIDEO_CODEC,
codec, NULL);
}
return;
bail:
GST_WARNING ("Unknown Video code-type=%d, sub-type=%d", stream->codec_type, stream->codec_sub_type);
return;
}
static void aiurdemux_parse_audio (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index)
{
gchar *mime = NULL;
const gchar *codec = NULL;
const gchar *codec_mime = NULL;
const gchar *stream_type = NULL;
gchar *padname;
int32 parser_ret = PARSER_SUCCESS;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
memset(&stream->info.audio, 0, sizeof(AiurDemuxAudioInfo));
parser_ret = IParser->getAudioNumChannels(handle,track_index,&stream->info.audio.n_channels);
if(parser_ret != PARSER_SUCCESS)
goto bail;
parser_ret = IParser->getAudioSampleRate(handle,track_index,&stream->info.audio.rate);
if(parser_ret != PARSER_SUCCESS)
goto bail;
if(IParser->getAudioBitsPerSample)
parser_ret = IParser->getAudioBitsPerSample(handle,track_index,&stream->info.audio.sample_width);
if(parser_ret != PARSER_SUCCESS)
goto bail;
if (stream->info.audio.n_channels == 0) {
stream->info.audio.n_channels = AIURDEMUX_AUDIO_CHANNEL_DEFAULT;
}
if (stream->info.audio.rate == 0) {
stream->info.audio.rate = AIURDEMUX_AUDIO_SAMPLERATE_DEFAULT;
}
if (stream->info.audio.sample_width == 0) {
stream->info.audio.sample_width = AIURDEMUX_AUDIO_SAMPLEWIDTH_DEFAULT;
}
stream->send_codec_data = TRUE;
switch (stream->codec_type) {
case AUDIO_AAC:
codec_mime = "audio/mpeg, mpegversion=(int)4";
codec = "AAC";
stream->send_codec_data= TRUE;
switch (stream->codec_sub_type) {
case AUDIO_AAC_ADTS:
stream_type = "adts";
break;
case AUDIO_AAC_ADIF:
stream_type = "adif";
break;
case AUDIO_AAC_RAW:
stream_type = "raw";
break;
case AUDIO_ER_BSAC:
codec_mime = "audio/x-bsac";
break;
default:
stream_type = NULL;
break;
}
if (stream_type) {
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld, stream-format=%s",
codec_mime, stream->info.audio.n_channels,
stream->info.audio.rate, stream->bitrate, stream_type);
} else {
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
codec_mime, stream->info.audio.n_channels,
stream->info.audio.rate, stream->bitrate);
}
break;
case AUDIO_MPEG2_AAC:
codec_mime = "audio/mpeg, mpegversion=(int)2";
codec = "AAC";
stream->send_codec_data = TRUE;
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld", codec_mime,
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_MP3:
codec_mime =
"audio/mpeg, mpegversion=(int)1";
codec = "MP3";
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld", codec_mime,
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_AC3:
codec_mime = "audio/x-ac3";
codec = "AC3";
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld, framed=(boolean)true",
codec_mime, stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_WMA:
parser_ret = IParser->getAudioBlockAlign(handle,track_index,&stream->info.audio.block_align);
if(parser_ret != PARSER_SUCCESS)
goto bail;
switch (stream->codec_sub_type) {
case AUDIO_WMA1:
codec_mime = "audio/x-wma, wmaversion=(int)1";
codec = "WMA7";
break;
case AUDIO_WMA2:
codec_mime = "audio/x-wma, wmaversion=(int)2";
codec = "WMA8";
break;
case AUDIO_WMA3:
codec_mime = "audio/x-wma, wmaversion=(int)3";
codec = "WMA9";
break;
case AUDIO_WMALL:
codec_mime = "audio/x-wma, wmaversion=(int)4";
codec = "WMA9 Lossless";
break;
default:
goto bail;
break;
}
stream->send_codec_data = TRUE;
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, block_align=(int)%ld, depth=(int)%ld, bitrate=(int)%ld",
codec_mime, stream->info.audio.n_channels, stream->info.audio.rate,
stream->info.audio.block_align, stream->info.audio.sample_width,
stream->bitrate);
break;
case AUDIO_WMS:
parser_ret = IParser->getAudioBlockAlign(handle,track_index,&stream->info.audio.block_align);
if(parser_ret != PARSER_SUCCESS)
goto bail;
stream->send_codec_data = TRUE;
codec_mime = "audio/x-wms";
codec = "WMA Voice";
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, block_align=(int)%ld, depth=(int)%ld, bitrate=(int)%ld",
codec_mime, stream->info.audio.n_channels, stream->info.audio.rate,
stream->info.audio.block_align, stream->info.audio.sample_width,
stream->bitrate);
break;
case AUDIO_APE:
codec_mime = "audio/x-ffmpeg-parsed-ape";
codec = "APE monkey's Audio";
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld, framed=(boolean)true, depth=(int)%ld",
codec_mime, stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate, stream->info.audio.sample_width);
break;
case AUDIO_PCM:
{
int width, depth, endian;
gboolean sign = TRUE;
switch (stream->codec_sub_type) {
case AUDIO_PCM_U8:
width = depth = 8;
endian = G_BYTE_ORDER;
sign = FALSE;
codec_mime = "format=(string)U8";
break;
case AUDIO_PCM_S16LE:
width = depth = 16;
endian = G_LITTLE_ENDIAN;
codec_mime = "format=(string)S16LE";
break;
case AUDIO_PCM_S24LE:
width = depth = 24;
endian = G_LITTLE_ENDIAN;
codec_mime = "format=(string)S24LE";
break;
case AUDIO_PCM_S32LE:
width = depth = 32;
endian = G_LITTLE_ENDIAN;
codec_mime = "format=(string)S32LE";
break;
case AUDIO_PCM_S16BE:
width = depth = 16;
endian = G_BIG_ENDIAN;
codec_mime = "format=(string)S16BE";
break;
case AUDIO_PCM_S24BE:
width = depth = 24;
endian = G_BIG_ENDIAN;
codec_mime = "format=(string)S24BE";
break;
case AUDIO_PCM_S32BE:
width = depth = 32;
endian = G_BIG_ENDIAN;
codec_mime = "format=(string)S32BE";
break;
default:
goto bail;
break;
}
codec = "PCM";
mime =
g_strdup_printf
("audio/x-raw, %s,channels=(int)%ld, layout=(string)interleaved, rate=(int)%ld,bitrate=(int)%ld",codec_mime,
stream->info.audio.n_channels, stream->info.audio.rate,stream->bitrate);
}
break;
case AUDIO_REAL:
switch (stream->codec_sub_type) {
case REAL_AUDIO_RAAC:
mime =
g_strdup_printf
("audio/mpeg, mpegversion=(int)4, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
codec = "AAC";
break;
case REAL_AUDIO_SIPR:
mime =
g_strdup_printf
("audio/x-sipro, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
codec = "SIPRO";
break;
case REAL_AUDIO_ATRC:
/* mime =
g_strdup_printf
("audio/x-vnd.sony.atrac3, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
codec = "ATRC";*/
break;
default:
{
uint32 frame_bit;
parser_ret = IParser->getAudioBitsPerFrame(handle,track_index,&frame_bit);
if(parser_ret != PARSER_SUCCESS)
goto bail;
mime =
g_strdup_printf
("audio/x-pn-realaudio, channels=(int)%ld, rate=(int)%ld, frame_bit=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
frame_bit);
codec = "RealAudio";
stream->send_codec_data = TRUE;
}
break;
}
break;
case AUDIO_VORBIS:
codec = "VORBIS";
mime =
g_strdup_printf
("audio/x-vorbis, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld, framed=(boolean)true",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
if(demux->option.disable_vorbis_codec_data){
stream->send_codec_data = FALSE;
}else{
stream->send_codec_data = TRUE;
}
break;
case AUDIO_FLAC:
codec = "FLAC";
mime =
g_strdup_printf
("audio/x-flac, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_DTS:
codec = "DTS";
mime =
g_strdup_printf
("audio/x-dts, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUIDO_SPEEX:
codec = "SPEEX";
mime =
g_strdup_printf
("audio/x-speex, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_AMR:
switch (stream->codec_sub_type) {
case AUDIO_AMR_NB:
codec_mime = "audio/AMR";
codec = "AMR-NB";
if (stream->info.audio.rate != 8000) {
GST_WARNING
("amr-nb should using 8k rate, this maybe a core parser BUG!");
stream->info.audio.rate = 8000;
}
break;
case AUDIO_AMR_WB:
codec_mime = "audio/AMR-WB";
codec = "AMR-WB";
break;
default:
goto bail;
break;
}
stream->send_codec_data = TRUE;
//only support one channel amr
stream->info.audio.n_channels = 1;
mime =
g_strdup_printf
("%s, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
codec_mime, stream->info.audio.n_channels, stream->info.audio.rate,
stream->info.audio.sample_width, stream->bitrate);
break;
case AUDIO_EC3:
codec = "Dobly Digital Plus (E-AC3)";
mime =
g_strdup_printf
("audio/eac3, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
case AUDIO_OPUS:
codec = "OPUS";
mime =
g_strdup_printf
("audio/x-opus, channel-mapping-family=(int)0, channels=(int)%ld, rate=(int)%ld, bitrate=(int)%ld",
stream->info.audio.n_channels, stream->info.audio.rate,
stream->bitrate);
break;
default:
break;
}
if(mime == NULL)
goto bail;
stream->caps = gst_caps_from_string (mime);
g_free (mime);
if (stream->pid < 0) {
stream->pid = demux->n_audio_streams;
}
padname = g_strdup_printf ("audio_%u", stream->pid);
GST_INFO ("Create audio pad %s", padname);
stream->pad =
gst_pad_new_from_static_template (&gst_aiurdemux_audiosrc_template,
padname);
g_free (padname);
demux->n_audio_streams++;
stream->pending_tags = gst_tag_list_new (GST_TAG_CODEC, codec, NULL);
if (stream->lang[0] != '\0') {
gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
GST_TAG_LANGUAGE_CODE, stream->lang, NULL);
}
if (stream->bitrate) {
gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
GST_TAG_BITRATE, stream->bitrate, NULL);
}
if (demux->tag_list) {
gst_tag_list_add (demux->tag_list,
GST_TAG_MERGE_REPLACE, GST_TAG_AUDIO_CODEC, codec, NULL);
}
return;
bail:
GST_WARNING ("Unknown Audio code-type=%d, sub-type=%d",
stream->codec_type, stream->codec_sub_type);
return;
}
static void aiurdemux_parse_text (GstAiurDemux * demux, AiurDemuxStream * stream,
gint track_index)
{
gchar *mime = NULL;
const gchar *codec_mime = NULL;
gchar *padname;
int32 parser_ret = PARSER_SUCCESS;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
parser_ret = IParser->getTextTrackWidth(handle,track_index,&stream->info.subtitle.width);
if(parser_ret != PARSER_SUCCESS)
goto bail;
parser_ret = IParser->getTextTrackHeight(handle,track_index,&stream->info.subtitle.height);
if(parser_ret != PARSER_SUCCESS)
goto bail;
stream->send_codec_data = TRUE;
switch (stream->codec_type) {
#if 0
case TXT_DIVX_FEATURE_SUBTITLE:
codec_mime = "subpicture/x-xsub";
mime =
g_strdup_printf ("%s, width=(int)%ld, height=(int)%ld", codec_mime,
stream->info.subtitle.width, stream->info.subtitle.height);
break;
case TXT_QT_TEXT:
codec_mime = "application/x-subtitle-qttext";
mime = g_strdup_printf ("application/x-subtitle-qttext");
break;
#endif
case TXT_3GP_STREAMING_TEXT:
case TXT_SUBTITLE_TEXT:
codec_mime = "text/x-raw";
mime = g_strdup_printf ("text/x-raw, format=(string)pango-markup");
break;
case TXT_SUBTITLE_SSA:
codec_mime = "application/x-ssa";
mime = g_strdup_printf ("application/x-ssa");
break;
case TXT_SUBTITLE_ASS:
codec_mime = "application/x-ass";
mime = g_strdup_printf ("application/x-ass");
break;
#if 0
case TXT_DIVX_MENU_SUBTITLE:
case TXT_TYPE_UNKNOWN:
GST_WARNING ("Unknown Text code-type=%d, sub-type=%d",
stream->codec_type, stream->codec_sub_type);
codec_mime = "application/x-subtitle-unknown";
mime = g_strdup_printf ("application/x-subtitle-unknown");
break;
#endif
default:
GST_WARNING ("Unsupported Text code-type=%d, sub-type=%d",
stream->codec_type, stream->codec_sub_type);
goto bail;
}
stream->caps = gst_caps_from_string (mime);
g_free (mime);
if (stream->pid < 0) {
stream->pid = demux->n_sub_streams;
}
padname = g_strdup_printf ("subtitle_%u", stream->pid);
GST_INFO ("Create text pad %s", padname);
stream->pad =
gst_pad_new_from_static_template (&gst_aiurdemux_subsrc_template,
padname);
g_free (padname);
stream->pending_tags = gst_tag_list_new (GST_TAG_CODEC, codec_mime, NULL);
if (stream->lang[0] != '\0') {
gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
GST_TAG_LANGUAGE_CODE, stream->lang, NULL);
}
if (demux->tag_list) {
gst_tag_list_add (demux->tag_list,
GST_TAG_MERGE_REPLACE, GST_TAG_SUBTITLE_CODEC, codec_mime, NULL);
}
demux->n_sub_streams++;
bail:
return;
}
static void aiurdemux_check_interleave_stream_eos (GstAiurDemux * demux)
{
int n;
gint track_num = 0;
gint64 min_time = -1;
AiurDemuxStream *stream;
AiurDemuxStream *min_stream = NULL;
gboolean bQueueFull = FALSE;
if(demux->n_streams <= 1)
return;
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
if (!stream->valid) {
continue;
}
if ((demux->interleave_queue_size)
&& (stream->buf_queue_size > demux->interleave_queue_size)) {
GST_LOG_OBJECT(demux,"bQueueFull ");
bQueueFull = TRUE;
}
if(min_time < 0){
min_time = stream->last_stop;
track_num = stream->track_idx;
min_stream = stream;
}else if (min_time > 0 && stream->last_stop < min_time ) {
min_time = stream->last_stop;
track_num = stream->track_idx;
min_stream = stream;
}
}
if(bQueueFull && (min_stream->buf_queue) && (g_queue_is_empty (min_stream->buf_queue))){
MARK_STREAM_EOS (demux, min_stream);
GST_ERROR_OBJECT(demux,"file mode interleave detect !!! send EOS to track%d",track_num);
}
return;
}
static void
_gst_buffer_copy_into_mem (GstBuffer * dest, gsize offset, const guint8 * src,
gsize size)
{
gsize bsize;
g_return_if_fail (gst_buffer_is_writable (dest));
bsize = gst_buffer_get_size (dest);
g_return_if_fail (bsize >= offset + size);
gst_buffer_fill (dest, offset, src, size);
}
static GstFlowReturn aiurdemux_read_buffer (GstAiurDemux * demux, uint32* track_idx, AiurDemuxStream** stream_out)
{
GstFlowReturn ret = GST_FLOW_OK;
int32 parser_ret = PARSER_ERR_UNKNOWN;
GstBuffer *gstbuf;
uint8 *buffer;
uint32 buffer_size;
uint64 usStartTime;
uint64 usDuration;
uint32 direction;
uint32 sampleFlags = 0;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
AiurDemuxStream *stream = NULL;
do{
gstbuf = NULL;
buffer = NULL;
buffer_size = 0;
usStartTime = 0;
usDuration = 0;
sampleFlags = 0;
if(demux->play_mode != AIUR_PLAY_MODE_NORMAL){
if (demux->play_mode == AIUR_PLAY_MODE_TRICK_FORWARD) {
direction = FLAG_FORWARD;
} else {
direction = FLAG_BACKWARD;
}
}
if (demux->read_mode == PARSER_READ_MODE_FILE_BASED) {
if (demux->play_mode == AIUR_PLAY_MODE_NORMAL) {
parser_ret = IParser->getFileNextSample(handle,track_idx,&buffer,(void *) (&gstbuf),
&buffer_size,&usStartTime, &usDuration, &sampleFlags);
}else {
parser_ret = IParser->getFileNextSyncSample(handle, direction, track_idx, &buffer,
(void *) (&gstbuf), &buffer_size, &usStartTime, &usDuration, &sampleFlags);
}
}else{
if (demux->play_mode == AIUR_PLAY_MODE_NORMAL) {
parser_ret = IParser->getNextSample(handle,(uint32)(*track_idx),&buffer,(void *) (&gstbuf),
&buffer_size,&usStartTime, &usDuration, &sampleFlags);
}else{
parser_ret = IParser->getNextSyncSample(handle, direction, (uint32)(*track_idx), &buffer,
(void *) (&gstbuf), &buffer_size, &usStartTime, &usDuration, &sampleFlags);
}
}
GST_LOG_OBJECT(demux,"aiurdemux_read_buffer ret=%d,track=%d,size=%d,time=%lld,duration=%lld,flag=%x",
parser_ret,*track_idx,buffer_size,usStartTime,usDuration,sampleFlags);
stream = aiurdemux_trackidx_to_stream (demux, *track_idx);
if((parser_ret == PARSER_EOS) || (PARSER_BOS == parser_ret)
|| (PARSER_READ_ERROR == parser_ret)){
if (demux->read_mode == PARSER_READ_MODE_FILE_BASED) {
aiurdemux_send_stream_eos_all (demux);
ret = GST_FLOW_EOS;
goto beach;
}else{
aiurdemux_send_stream_eos (demux, stream);
if (demux->valid_mask == 0) {
ret = GST_FLOW_EOS;
goto beach;
}
if(PARSER_READ_ERROR == parser_ret)
goto beach;
}
} else if (PARSER_ERR_INVALID_MEDIA == parser_ret || PARSER_SEEK_ERROR == parser_ret) {
GST_WARNING ("Movie parser interrupt, track_idx %d, error = %d",
*track_idx, parser_ret);
if (stream) {
aiurdemux_send_stream_eos (demux, stream);
if (demux->valid_mask == 0) {
ret = GST_FLOW_EOS;
}
} else {
aiurdemux_send_stream_eos_all (demux);
ret = GST_FLOW_EOS;
}
goto beach;
} else if (PARSER_NOT_READY == parser_ret && stream->type == MEDIA_TEXT) {
GST_WARNING ("read track not ready, track_idx %d", *track_idx);
int n;
gint64 min_time = G_MAXINT64;
for (n = 0; n < demux->n_streams; n++) {
if (!demux->streams[n]->valid || demux->streams[n]->type == MEDIA_TEXT) {
continue;
}
if (GST_CLOCK_TIME_IS_VALID(demux->streams[n]->last_stop) &&
GST_CLOCK_TIME_IS_VALID(demux->streams[n]->last_start) &&
demux->streams[n]->last_stop < min_time) {
min_time = demux->streams[n]->last_stop;
}
}
GST_INFO ("min_time=%lld\n", min_time);
if (GST_CLOCK_TIME_IS_VALID(stream->time_position) &&
min_time != G_MAXINT64 &&
stream->time_position + GST_SECOND <= min_time) {
if (stream->new_segment) {
aiurdemux_send_stream_newsegment (demux, stream);
}
GstEvent *gap = gst_event_new_gap (stream->time_position, GST_SECOND);
stream->last_start = stream->time_position;
stream->last_stop = stream->time_position + GST_SECOND;
gst_pad_push_event (stream->pad, gap);
GST_INFO ("TEXT GAP event sent %d, time_position=%lld, "
"last_start=%lld, last_stop=%lld\n", *track_idx,
stream->time_position, stream->last_start, stream->last_stop);
stream->time_position = stream->last_stop;
}
goto readend;
} else if (PARSER_SUCCESS != parser_ret) {
GST_ERROR ("Movie parser failed, error = %d", parser_ret);
aiurdemux_send_stream_eos_all (demux);
ret = GST_FLOW_ERROR;
goto beach;
}
if(gstbuf && gst_buffer_get_size(gstbuf) != buffer_size){
gst_buffer_set_size(gstbuf,buffer_size);
}
if ((sampleFlags & FLAG_SAMPLE_CODEC_DATA) && (stream->send_codec_data) && (buffer_size)) {
GstCaps *caps;
caps = gst_caps_copy(stream->caps);
if(caps){
gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, gstbuf, NULL);
}
gst_buffer_unref (gstbuf);
gst_caps_unref(stream->caps);
stream->caps = caps;
gst_pad_set_caps (stream->pad, stream->caps);
return ret;
}
AIUR_UPDATE_SAMPLE_STAT (stream->sample_stat,
AIUR_CORETS_2_GSTTS (usStartTime),
AIUR_COREDURATION_2_GSTDURATION (usDuration), sampleFlags);
if(!(sampleFlags & FLAG_SAMPLE_NOT_FINISHED) && stream->partial_sample == FALSE){
stream->buffer = gstbuf;
GST_LOG_OBJECT(demux,"get stream buffer 1");
}else{
if(buffer_size > 0){
stream->adapter_buffer_size += gst_buffer_get_size(gstbuf);
gst_adapter_push (stream->adapter, gstbuf);
gstbuf = NULL;
GST_LOG_OBJECT(demux,"push to adapter 2 ");
}
if (sampleFlags & FLAG_SAMPLE_NOT_FINISHED) {
stream->partial_sample = TRUE;
}else{
gint sample_size = 0;
stream->partial_sample = FALSE;
sample_size = gst_adapter_available (stream->adapter);
if(sample_size > 0){
stream->buffer = gst_adapter_take_buffer (stream->adapter, stream->adapter_buffer_size);
stream->adapter_buffer_size = 0;
gst_adapter_clear (stream->adapter);
GST_LOG_OBJECT(demux,"get stream buffer 2");
}
}
}
readend:
;
}while(sampleFlags & FLAG_SAMPLE_NOT_FINISHED);
if(stream->buffer){
if (!(stream->sample_stat.flag & FLAG_SYNC_SAMPLE)) {
GST_BUFFER_FLAG_SET (stream->buffer, GST_BUFFER_FLAG_DELTA_UNIT);
}
if (demux->play_mode != AIUR_PLAY_MODE_NORMAL && stream->buffer) {
GST_BUFFER_FLAG_SET (stream->buffer, GST_BUFFER_FLAG_DISCONT);
}
}
if (stream->sample_stat.start == stream->last_start
&& !(stream->type == MEDIA_VIDEO && stream->codec_type == VIDEO_ON2_VP)) {
stream->sample_stat.start = GST_CLOCK_TIME_NONE;
}
*stream_out = stream;
return ret;
beach:
if (stream) {
if (stream->buffer) {
gst_buffer_unref (stream->buffer);
stream->buffer = NULL;
}
gst_adapter_clear (stream->adapter);
stream->sample_stat.duration = 0;
stream->sample_stat.start = GST_CLOCK_TIME_NONE;
stream->sample_stat.flag = 0;
}
return ret;
}
static GstFlowReturn aiurdemux_parse_vorbis_codec_data(GstAiurDemux * demux, AiurDemuxStream* stream)
{
int offset = 0;
int32 header1 = 0;
int32 header2 = 0;
int32 header3 = 0;
int32 len1 = 0;
int32 len2 = 0;
int32 len3 = 0;
uint8 * inbuffer;
uint8 * vorbisPtr;
if(demux == NULL || stream == NULL)
return GST_FLOW_ERROR;
if(stream->codec_data.length == 0 || stream->codec_data.codec_data == NULL)
return GST_FLOW_ERROR;
inbuffer = stream->codec_data.codec_data;
while(offset + 6 < stream->codec_data.length){
vorbisPtr = inbuffer+offset+1;
if(inbuffer[offset] == 0x01){
if(!memcmp(vorbisPtr,"vorbis",6)){
header1 = offset;
offset += 6;
}
}else if(inbuffer[offset] == 0x03){
if(!memcmp(vorbisPtr,"vorbis",6)){
header2 = offset;
offset += 6;
}
}else if(inbuffer[offset] == 0x05){
if(!memcmp(vorbisPtr,"vorbis",6)){
header3 = offset;
break;
}
}
offset ++;
}
len1 = header2 - header1;
len2 = header3 - header2;
len3 = stream->codec_data.length - header3;
if(header1 < header2 && header2 < header3){
GstBuffer *gstbuf;
gstbuf = gst_buffer_new_and_alloc (len1);
gst_buffer_fill(gstbuf,0,(guint8 *)(stream->codec_data.codec_data+header1),len1);
gst_pad_push (stream->pad, gstbuf);
gstbuf = NULL;
gstbuf = gst_buffer_new_and_alloc (len2);
gst_buffer_fill(gstbuf,0,(guint8 *)(stream->codec_data.codec_data+header2),len2);
gst_pad_push (stream->pad, gstbuf);
gstbuf = NULL;
gstbuf = gst_buffer_new_and_alloc (len3);
gst_buffer_fill(gstbuf,0,(guint8 *)(stream->codec_data.codec_data+header3),len3);
gst_pad_push (stream->pad, gstbuf);
GST_DEBUG_OBJECT (demux, "push vorbis codec buffer totalLen=%d,1=%d,2=%d,3=%d",
stream->codec_data.length,header1,header2,header3);
}
return GST_FLOW_OK;
}
static gint aiurdemux_choose_next_stream (GstAiurDemux * demux)
{
int n, i;
gint track_index = 0;
gint64 min_time = -1;
AiurDemuxStream *stream;
if (demux->sub_read_ready) {
if (demux->sub_read_cnt < demux->n_sub_streams) {
demux->sub_read_cnt++;
guint32 sub_idx = 0;
for (n = 0; n < demux->n_streams; n++) {
if (demux->streams[n]->type == MEDIA_TEXT) {
sub_idx++;
if (sub_idx == demux->sub_read_cnt) {
if (demux->streams[n]->valid)
return demux->streams[n]->track_idx;
else
demux->sub_read_cnt++;
}
}
}
} else {
demux->sub_read_cnt = 0;
demux->sub_read_ready = FALSE;
}
}
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
if (!stream->valid) {
continue;
}
if (stream->type == MEDIA_TEXT)
continue;
if ((demux->read_mode == PARSER_READ_MODE_TRACK_BASED)
&& (stream->partial_sample)) {
track_index = stream->track_idx;
break;
}
if ((demux->interleave_queue_size)
&& (stream->buf_queue_size > demux->interleave_queue_size)) {
track_index = stream->track_idx;
break;
}
if (stream->last_stop == GST_CLOCK_TIME_NONE) {
if (demux->read_mode==PARSER_READ_MODE_FILE_BASED) {
track_index = stream->track_idx;
if (stream->buf_queue && !g_queue_is_empty(stream->buf_queue)) {
break;
} else {
continue;
}
}else {
/* in track mode we will check other tracks for -1 ts, if there is buf_queue, use that track, else use the first -1 ts track */
track_index = stream->track_idx;
for (i=n; i< demux->n_streams; i++) {
stream = demux->streams[i];
if (stream->last_stop == GST_CLOCK_TIME_NONE ){
if (stream->buf_queue && !g_queue_is_empty(stream->buf_queue)){
track_index = stream->track_idx;
break;
}
}
}
break;
}
}
if (min_time >= 0) {
if (stream->last_stop < min_time) {
min_time = stream->last_stop;
track_index = stream->track_idx;
}
} else {
min_time = stream->last_stop;
track_index = stream->track_idx;
}
}
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
if (track_index == stream->track_idx) {
if (stream->type == MEDIA_VIDEO) {
demux->sub_read_ready = TRUE;
demux->sub_read_cnt = 0;
}
}
}
return track_index;
}
static AiurDemuxStream* aiurdemux_trackidx_to_stream (GstAiurDemux * demux, guint32 stream_idx)
{
AiurDemuxStream *stream = NULL;
int i;
for (i = 0; i < demux->n_streams; i++) {
if (demux->streams[i]->track_idx == stream_idx) {
stream = demux->streams[i];
break;
}
}
return stream;
}
#define DO_RUNNING_AVG(avg,val,size) (((val) + ((size)-1) * (avg)) / (size))
/* generic running average, this has a neutral window size */
#define UPDATE_RUNNING_AVG(avg,val) DO_RUNNING_AVG(avg,val,10)
static void
aiurdemux_check_start_offset (GstAiurDemux * demux, AiurDemuxStream * stream)
{
GstClockTime base_time,now;
GstClock *clock = NULL;
GstClockTimeDiff offset = 0;
GstClockTimeDiff in_diff;
base_time = GST_ELEMENT_CAST (demux)->base_time;
clock = GST_ELEMENT_CLOCK (demux);
if(clock != NULL){
now = gst_clock_get_time (clock);
offset = now - base_time;
GST_LOG_OBJECT (demux,"media time =%"GST_TIME_FORMAT,GST_TIME_ARGS (offset));
//clock of pipeline has started when first buffer arrives, so adjust the buffer timestamp
if(demux->clock_offset == GST_CLOCK_TIME_NONE && offset > 0){
demux->clock_offset = offset;
GST_LOG_OBJECT (demux,"first clock offset =%"GST_TIME_FORMAT,GST_TIME_ARGS (offset));
}
}
if(stream->last_stop == 0 && (GST_CLOCK_TIME_IS_VALID (demux->clock_offset))){
stream->last_stop = demux->clock_offset;
GST_LOG_OBJECT (demux,"last_stop =%"GST_TIME_FORMAT,GST_TIME_ARGS (stream->last_stop));
}
if(demux->start_time == GST_CLOCK_TIME_NONE){
demux->start_time = stream->sample_stat.start;
GST_LOG_OBJECT (demux,"start_time=%"GST_TIME_FORMAT,GST_TIME_ARGS (demux->start_time));
}
if (demux->isMPEG && aiurcontent_is_live(demux->content_info) &&
GST_CLOCK_TIME_IS_VALID(stream->sample_stat.start)) {
/* check stream time stamp discontinuity */
if ((GST_CLOCK_TIME_IS_VALID(stream->last_timestamp)) &&
((stream->sample_stat.start < stream->last_timestamp - AIURDEMUX_TIMESTAMP_DISCONT_MAX_GAP) ||
(stream->sample_stat.start > stream->last_timestamp + AIURDEMUX_TIMESTAMP_DISCONT_MAX_GAP))) {
GST_INFO_OBJECT(demux,"timestamp discontinuity, stream %d start_time: %lld --> %lld",
stream->track_idx, demux->start_time, stream->sample_stat.start);
GST_INFO_OBJECT(demux,"timestamp discontinuity, stream %d clock offset: %lld --> %lld",
stream->track_idx, demux->clock_offset, offset);
demux->start_time = stream->sample_stat.start;
demux->clock_offset = offset;
}
stream->last_timestamp = stream->sample_stat.start;
/* monitoring the gap between media time and current time stamp */
gint64 new_ts = stream->sample_stat.start - demux->start_time + demux->clock_offset;
if((new_ts + (GST_MSECOND*demux->option.streaming_latency/2)) < offset) {
//new ts lag last for AIURDEMUX_TIMESTAMP_LAG_MAX_TIME, then change to new start time
if (stream->lag_time != GST_CLOCK_TIME_NONE) {
if ((offset - stream->lag_time) > AIURDEMUX_TIMESTAMP_LAG_MAX_TIME) {
GST_INFO_OBJECT(demux,"clock lag, stream %d start_time: %lld --> %lld",
stream->track_idx, demux->start_time, stream->sample_stat.start);
GST_INFO_OBJECT(demux,"clock lag, stream %d clock offset: %lld --> %lld",
stream->track_idx, demux->clock_offset, offset);
demux->start_time = stream->sample_stat.start;
demux->clock_offset = offset;
stream->lag_time = GST_CLOCK_TIME_NONE;
}
} else {
stream->lag_time = offset;
}
} else {
stream->lag_time = GST_CLOCK_TIME_NONE;
//new ts is larger than meida time by far, align it to media time
if (new_ts - offset > AIURDEMUX_TIMESTAMP_LAG_MAX_TIME) {
stream->sample_stat.start = offset - demux->clock_offset + demux->start_time;
GST_INFO_OBJECT(demux, "timestamp gap, align to mediatime %lld", offset);
}
}
}
if((GST_CLOCK_TIME_IS_VALID (demux->clock_offset))
&& (GST_CLOCK_TIME_IS_VALID (demux->start_time))
&& (GST_CLOCK_TIME_IS_VALID (stream->sample_stat.start))){
stream->sample_stat.start = stream->sample_stat.start - demux->start_time
+ demux->clock_offset + demux->media_offset + (GST_MSECOND * demux->option.streaming_latency);
GST_LOG_OBJECT (demux,"***start=%"GST_TIME_FORMAT,GST_TIME_ARGS (stream->sample_stat.start));
}
if(GST_CLOCK_TIME_IS_VALID (stream->sample_stat.start) && demux->option.streaming_latency> 0
&& demux->option.low_latency_tolerance > 0){
in_diff = stream->sample_stat.start - offset;
if (demux->avg_diff == 0)
demux->avg_diff = in_diff;
else
demux->avg_diff = UPDATE_RUNNING_AVG (demux->avg_diff, in_diff);
GST_LOG_OBJECT (demux,"***diff=%"GST_TIME_FORMAT,GST_TIME_ARGS (demux->avg_diff));
if( demux->avg_diff > (gint64)GST_MSECOND * (demux->option.streaming_latency+demux->option.low_latency_tolerance)){
demux->media_offset -= GST_MSECOND * demux->option.low_latency_tolerance*5/4;
demux->avg_diff = 0;
GST_LOG_OBJECT(demux,"***media_offset 1=%lld",demux->media_offset);
}else if(demux->avg_diff < (gint64)GST_MSECOND*(demux->option.streaming_latency - demux->option.low_latency_tolerance)){
demux->media_offset += (GST_MSECOND * demux->option.low_latency_tolerance*3/4);
demux->avg_diff = 0;
GST_LOG_OBJECT (demux,"***media_offset 2=%lld",demux->media_offset);
}
}
}
static void
aiurdemux_adjust_timestamp (GstAiurDemux * demux, AiurDemuxStream * stream,
GstBuffer * buffer)
{
//g_print("adjust orig %"GST_TIME_FORMAT" base %"GST_TIME_FORMAT" pos %"GST_TIME_FORMAT"\n",
// GST_TIME_ARGS(stream->sample_stat.start), GST_TIME_ARGS(demux->base_offset), GST_TIME_ARGS(stream->time_position));
buffer = gst_buffer_make_writable (buffer);
if ((demux->base_offset == 0)
|| (!GST_CLOCK_TIME_IS_VALID (stream->sample_stat.start))) {
GST_BUFFER_TIMESTAMP (buffer) = stream->sample_stat.start;
} else {
GST_BUFFER_TIMESTAMP (buffer) =
((stream->sample_stat.start >=
demux->base_offset) ? (stream->sample_stat.start -
demux->base_offset) : 0);
if ((GST_BUFFER_TIMESTAMP (buffer) < (stream->time_position))) {
GST_BUFFER_TIMESTAMP (buffer) = stream->time_position;
}
}
GST_BUFFER_DTS(buffer) = GST_BUFFER_TIMESTAMP (buffer);
GST_BUFFER_DURATION (buffer) = stream->sample_stat.duration;
GST_BUFFER_OFFSET (buffer) = -1;
GST_BUFFER_OFFSET_END (buffer) = -1;
}
static void
aiurdemux_update_stream_position (GstAiurDemux * demux,
AiurDemuxStream * stream, GstBuffer * buffer)
{
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer))) {
stream->last_stop = stream->last_start = GST_BUFFER_TIMESTAMP (buffer);
stream->last_stop += GST_BUFFER_DURATION (buffer);
/* sample duration is wrong sometimes, so using the last_start here to
* compare with clip duration */
if (demux->n_video_streams > 0) {
if ((MEDIA_VIDEO == stream->type) &&
(GST_BUFFER_TIMESTAMP (buffer) > demux->movie_duration)) {
demux->movie_duration = GST_BUFFER_TIMESTAMP (buffer);
}
} else {
if (GST_BUFFER_TIMESTAMP (buffer) > demux->movie_duration) {
demux->movie_duration = GST_BUFFER_TIMESTAMP (buffer);
}
}
} else {
stream->last_stop = GST_CLOCK_TIME_NONE;
}
}
static void
aiurdemux_send_stream_newsegment (GstAiurDemux * demux,
AiurDemuxStream * stream)
{
GstSegment segment;
gst_segment_init (&segment, GST_FORMAT_TIME);
if (demux->segment.rate >= 0) {
if (demux->play_mode == AIUR_PLAY_MODE_TRICK_FORWARD &&
(stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT)) {
stream->new_segment = FALSE;
return;
}
if (stream->buffer) {
if ((GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (stream->buffer)))
&& (GST_BUFFER_TIMESTAMP (stream->buffer) > stream->time_position)) {
GST_WARNING ("Timestamp unexpect, maybe a core parser bug!");
if (demux->n_video_streams == 0) {
if (GST_BUFFER_TIMESTAMP (stream->buffer) > GST_SECOND)
stream->time_position =
GST_BUFFER_TIMESTAMP (stream->buffer) - GST_SECOND;
}
}
GST_WARNING ("Pad %s: Send newseg %" GST_TIME_FORMAT " first buffer %"
GST_TIME_FORMAT " ", AIUR_MEDIATYPE2STR (stream->type),
GST_TIME_ARGS (stream->time_position),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (stream->buffer)));
}
segment.format = GST_FORMAT_TIME;
segment.rate = demux->segment.rate;
segment.start = stream->time_position;
segment.stop = GST_CLOCK_TIME_NONE;
if (stream->track_duration > 0) {
segment.duration = stream->track_duration;
}
segment.position = segment.time = stream->time_position;
GST_DEBUG ("segment event %" GST_SEGMENT_FORMAT, &segment);
gst_pad_push_event (stream->pad, gst_event_new_segment (&segment));
} else {
if(stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT){
stream->new_segment = FALSE;
return;
}
if (stream->buffer) {
GST_WARNING ("Pad %s: Send newseg %" GST_TIME_FORMAT " first buffer %"
GST_TIME_FORMAT " ", AIUR_MEDIATYPE2STR (stream->type),
GST_TIME_ARGS (stream->time_position),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (stream->buffer)));
}
segment.format = GST_FORMAT_TIME;
segment.rate = demux->segment.rate;
segment.start = 0;
segment.stop = stream->time_position;
segment.position = segment.time = 0;
GST_DEBUG ("segment event %" GST_SEGMENT_FORMAT, &segment);
gst_pad_push_event (stream->pad, gst_event_new_segment (&segment));
}
stream->new_segment = FALSE;
}
static GstFlowReturn
aiurdemux_send_stream_eos (GstAiurDemux * demux, AiurDemuxStream * stream)
{
GstFlowReturn ret = GST_FLOW_OK;
if (stream) {
if (stream->new_segment) {
aiurdemux_send_stream_newsegment (demux, stream);
}
ret = gst_pad_push_event (stream->pad, gst_event_new_eos ());
stream->valid = FALSE;
demux->valid_mask &= (~stream->mask);
GST_WARNING ("Pad %s: Send eos. ", AIUR_MEDIATYPE2STR (stream->type));
}
return ret;
}
static GstFlowReturn
aiurdemux_send_stream_eos_all (GstAiurDemux * demux)
{
GstFlowReturn ret = GST_FLOW_OK;
AiurDemuxStream *stream;
gint n;
if (demux->interleave_queue_size) {
while (demux->valid_mask) {
gint track = aiurdemux_choose_next_stream (demux);
stream = aiurdemux_trackidx_to_stream (demux, track);
if (stream) {
GstBuffer *gstbuf;
//GstFlowReturn ret;
gstbuf = g_queue_pop_head (stream->buf_queue);
if (gstbuf) {
stream->buf_queue_size -= gst_buffer_get_size(gstbuf);//GST_BUFFER_SIZE (gstbuf);
aiurdemux_push_pad_buffer (demux, stream, gstbuf);
} else {
aiurdemux_send_stream_eos (demux, stream);
}
} else {
break;
}
}
} else {
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
if ((stream->valid) && (stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT)) {
aiurdemux_send_stream_eos (demux, stream);
}
}
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
if (stream->valid) {
aiurdemux_send_stream_eos (demux, stream);
}
}
}
return ret;
}
static GstFlowReturn aiurdemux_push_pad_buffer (GstAiurDemux * demux, AiurDemuxStream * stream,
GstBuffer * buffer)
{
GstFlowReturn ret;
aiurdemux_update_stream_position (demux, stream, buffer);
if (stream->block) {
if ((GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer)))
&& (GST_BUFFER_TIMESTAMP (buffer) +
GST_BUFFER_DURATION (buffer) <
stream->time_position)) {
gst_buffer_unref(buffer);
ret = GST_FLOW_OK;
GST_LOG("drop %s buffer for block",AIUR_MEDIATYPE2STR (stream->type));
goto bail;
}
stream->block = FALSE;
}
GST_DEBUG_OBJECT (demux,"%s push sample %" GST_TIME_FORMAT " size %d is discont: %d is delta unit: %d",
AIUR_MEDIATYPE2STR (stream->type),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)), gst_buffer_get_size (buffer), \
GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT), \
GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT));
ret = gst_pad_push (stream->pad, buffer);
if ((ret != GST_FLOW_OK)) {
GST_WARNING ("Pad %s push error type %d",
AIUR_MEDIATYPE2STR (stream->type), ret);
if (ret == GST_FLOW_EOS) {
aiurdemux_send_stream_eos (demux, stream);
if (demux->valid_mask == 0) {
ret = GST_FLOW_EOS;
goto bail;
}
}
if (ret < GST_FLOW_EOS) {
goto bail;
}
}
ret = GST_FLOW_OK;
bail:
return ret;
}
static GstFlowReturn
aiurdemux_combine_flows (GstAiurDemux * demux, AiurDemuxStream * stream,
GstFlowReturn ret)
{
gint i;
gboolean unexpected = FALSE, not_linked = TRUE;
stream->last_ret = ret;
if (G_LIKELY (ret != GST_FLOW_EOS && ret != GST_FLOW_NOT_LINKED))
goto done;
for (i = 0; i < demux->n_streams; i++) {
AiurDemuxStream *ostream = demux->streams[i];
ret = ostream->last_ret;
if (G_LIKELY (ret != GST_FLOW_EOS && ret != GST_FLOW_NOT_LINKED))
goto done;
unexpected |= (ret == GST_FLOW_EOS);
not_linked &= (ret == GST_FLOW_NOT_LINKED);
}
if (not_linked)
ret = GST_FLOW_NOT_LINKED;
else if (unexpected)
ret = GST_FLOW_EOS;
done:
return ret;
}
static void aiurdemux_reset_stream (GstAiurDemux * demux, AiurDemuxStream * stream)
{
stream->valid = TRUE;
stream->new_segment = TRUE;
stream->last_ret = GST_FLOW_OK;
stream->last_stop = 0;
stream->last_start = GST_CLOCK_TIME_NONE;
stream->time_position = 0;
stream->pending_eos = FALSE;
stream->block = FALSE;
stream->last_timestamp = GST_CLOCK_TIME_NONE;
stream->lag_time = GST_CLOCK_TIME_NONE;
if (stream->buffer) {
gst_buffer_unref (stream->buffer);
stream->buffer = NULL;
}
stream->adapter_buffer_size = 0;
if (stream->adapter) {
gst_adapter_clear (stream->adapter);
}
if (stream->buf_queue) {
GstBuffer * gbuf;
while ((gbuf = g_queue_pop_head ((stream)->buf_queue))) {
gst_buffer_unref (gbuf);
};
}
stream->buf_queue_size = 0;
AIUR_RESET_SAMPLE_STAT(stream->sample_stat);
demux->valid_mask |= stream->mask;
demux->sub_read_ready = TRUE;
demux->sub_read_cnt = 0;
}
static gboolean
gst_aiurdemux_convert_seek (GstPad * pad, GstFormat * format,
GstSeekType cur_type, gint64 * cur, GstSeekType stop_type, gint64 * stop)
{
gboolean res;
GstFormat fmt;
g_return_val_if_fail (format != NULL, FALSE);
g_return_val_if_fail (cur != NULL, FALSE);
g_return_val_if_fail (stop != NULL, FALSE);
if (*format == GST_FORMAT_TIME)
return TRUE;
fmt = GST_FORMAT_TIME;
res = TRUE;
if (cur_type != GST_SEEK_TYPE_NONE)
res = gst_pad_query_convert (pad, *format, *cur, fmt, cur);
if (res && stop_type != GST_SEEK_TYPE_NONE)
res = gst_pad_query_convert (pad, *format, *stop, fmt, stop);
if (res)
*format = GST_FORMAT_TIME;
return res;
}
static gboolean
gst_aiurdemux_perform_seek (GstAiurDemux * demux, GstSegment * segment,
gint accurate)
{
gint64 desired_offset;
gint n;
int32 core_ret = 0;
gdouble rate = segment->rate;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
if (rate >= 0) {
demux->play_mode = AIUR_PLAY_MODE_NORMAL;
if ((rate > 2.0)
&& (((demux->read_mode == PARSER_READ_MODE_FILE_BASED)
&& (IParser->getFileNextSyncSample))
|| ((demux->read_mode == PARSER_READ_MODE_TRACK_BASED)
&& (IParser->getNextSyncSample)))) {
demux->play_mode = AIUR_PLAY_MODE_TRICK_FORWARD;
}
desired_offset = segment->start;
} else if (rate < 0) {
if (((demux->read_mode == PARSER_READ_MODE_FILE_BASED)
&& (IParser->getFileNextSyncSample))
|| ((demux->read_mode == PARSER_READ_MODE_TRACK_BASED)
&& (IParser->getNextSyncSample))) {
demux->play_mode = AIUR_PLAY_MODE_TRICK_BACKWARD;
desired_offset = segment->stop;
} else {
return FALSE;
}
}
//do not change play mode for pure audio file.
if((0 == demux->n_video_streams) && (demux->n_audio_streams >= 1) && (rate >= 0)){
demux->play_mode = AIUR_PLAY_MODE_NORMAL;
}
GST_WARNING ("Seek to %" GST_TIME_FORMAT ".", GST_TIME_ARGS (desired_offset));
demux->pending_event = FALSE;
demux->valid_mask = 0;
if ((accurate) || (demux->n_video_streams > 1)
|| (demux->n_video_streams == 0)) {
/* and set all streams to the final position */
for (n = 0; n < demux->n_streams; n++) {
AiurDemuxStream *stream = demux->streams[n];
guint64 usSeekTime = AIUR_GSTTS_2_CORETS (desired_offset);
aiurdemux_reset_stream (demux, stream);
IParser->seek(handle, stream->track_idx,&usSeekTime, SEEK_FLAG_NO_LATER);
stream->time_position = desired_offset;
if ((rate >= 0) && (stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT)
&& (demux->n_video_streams))
stream->block = TRUE;
else
stream->block = FALSE;
if ((core_ret != PARSER_SUCCESS)
|| ((demux->play_mode != AIUR_PLAY_MODE_NORMAL)
&& (stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT))) {
MARK_STREAM_EOS (demux, stream);
}
}
} else {
AiurDemuxStream *stream = NULL;
guint64 usSeekTime = AIUR_GSTTS_2_CORETS (desired_offset);
core_ret = PARSER_SUCCESS;
for (n = 0; n < demux->n_streams; n++) {
if (demux->streams[n]->type == MEDIA_VIDEO) {
stream = demux->streams[n];
break;
}
}
if (stream) {
aiurdemux_reset_stream (demux, stream);
IParser->seek(handle, stream->track_idx,
&usSeekTime, SEEK_FLAG_NO_LATER);
GST_INFO ("Video seek return %d time %" GST_TIME_FORMAT, core_ret,
GST_TIME_ARGS (AIUR_CORETS_2_GSTTS (usSeekTime)));
if (core_ret != PARSER_SUCCESS) {
MARK_STREAM_EOS (demux, stream);
} else {
desired_offset = AIUR_CORETS_2_GSTTS (usSeekTime);
}
stream->time_position = desired_offset;
}
for (n = 0; n < demux->n_streams; n++) {
stream = demux->streams[n];
usSeekTime = AIUR_GSTTS_2_CORETS (desired_offset);
if (stream->type != MEDIA_VIDEO) {
aiurdemux_reset_stream (demux, stream);
if (core_ret == PARSER_SUCCESS) {
IParser->seek(handle, stream->track_idx,
&usSeekTime, SEEK_FLAG_NO_LATER);
stream->time_position = desired_offset;
if ((rate >= 0) && (stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT)
&& (demux->n_video_streams))
stream->block = TRUE;
else
stream->block = FALSE;
if ((core_ret != PARSER_SUCCESS)
|| ((demux->play_mode != AIUR_PLAY_MODE_NORMAL)
&& (stream->type == MEDIA_AUDIO || stream->type == MEDIA_TEXT))) {
MARK_STREAM_EOS (demux, stream);
}
core_ret = PARSER_SUCCESS;
} else {
MARK_STREAM_EOS (demux, stream);
}
}
}
}
//bail:
//segment->stop = desired_offset;
//segment->time = desired_offset;
return TRUE;
}
/* do a seek in push based mode */
static gboolean
aiurdemux_do_push_seek (GstAiurDemux * demux, GstPad * pad,
GstEvent * event)
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType cur_type, stop_type;
gint64 cur, stop;
gboolean flush;
gboolean update;
GstSegment seeksegment;
int i;
gboolean ret = FALSE;
if (event) {
GST_DEBUG_OBJECT (demux, "doing seek with event");
gst_event_parse_seek (event, &rate, &format, &flags,
&cur_type, &cur, &stop_type, &stop);
/* we have to have a format as the segment format. Try to convert
* if not. */
if (!gst_aiurdemux_convert_seek (pad, &format, cur_type, &cur,
stop_type, &stop)) {
goto no_format;
}
if (stop == (gint64) 0) {
stop = (gint64) - 1;
}
} else {
GST_DEBUG_OBJECT (demux, "doing seek without event");
flags = 0;
}
flush = flags & GST_SEEK_FLAG_FLUSH;
demux->loop_push = FALSE;
gst_aiur_stream_cache_close (demux->stream_cache);
/* wait for previous seek event done */
g_mutex_lock (&demux->seekmutex);
/* stop streaming, either by flushing or by pausing the task */
if (flush) {
gst_aiurdemux_push_event (demux, gst_event_new_flush_start ());
}
/* wait for streaming to finish */
g_mutex_lock (&demux->runmutex);
gst_aiur_stream_cache_open (demux->stream_cache);
memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
if (event) {
gst_segment_do_seek(&seeksegment, rate,
format, flags, cur_type, cur, stop_type, stop, &update);
}
/* prepare for streaming again */
if (flush) {
gst_aiurdemux_push_event (demux, gst_event_new_flush_stop (TRUE));
}
/* now do the seek, this actually never returns FALSE */
ret =
gst_aiurdemux_perform_seek (demux, &seeksegment,
(flags & GST_SEEK_FLAG_ACCURATE));
/* commit the new segment */
memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
if (demux->thread) {
g_thread_unref(demux->thread);
demux->thread = NULL;
}
demux->loop_push = TRUE;
gst_aiur_stream_cache_open (demux->stream_cache);
for (i = 0; i < demux->n_streams; i++)
demux->streams[i]->last_ret = GST_FLOW_OK;
demux->thread = g_thread_new ("aiur_push",(GThreadFunc) aiurdemux_loop_push, (gpointer) demux);
g_mutex_unlock (&demux->runmutex);
g_mutex_unlock (&demux->seekmutex);
return ret;
/* ERRORS */
no_format:
{
GST_DEBUG_OBJECT (demux, "unsupported format given, seek aborted.");
return ret;
}
}
/* do a seek in pull based mode */
static gboolean
aiurdemux_do_seek (GstAiurDemux * demux, GstPad * pad, GstEvent * event)
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType cur_type, stop_type;
gint64 cur, stop;
gboolean flush;
gboolean update;
GstSegment seeksegment;
int i;
gboolean ret = FALSE;
if (event) {
GST_DEBUG_OBJECT (demux, "doing seek with event");
gst_event_parse_seek (event, &rate, &format, &flags,
&cur_type, &cur, &stop_type, &stop);
if (stop == (gint64) 0) {
stop = (gint64) - 1;
}
/* we have to have a format as the segment format. Try to convert
* if not. */
if (!gst_aiurdemux_convert_seek (pad, &format, cur_type, &cur,
stop_type, &stop))
goto no_format;
GST_DEBUG_OBJECT (demux, "seek format %s",
gst_format_get_name (format));
} else {
GST_DEBUG_OBJECT (demux, "doing seek without event");
flags = 0;
}
flush = flags & GST_SEEK_FLAG_FLUSH;
/* wait for previous seek event done */
g_mutex_lock (&demux->seekmutex);
/* stop streaming by pausing the task */
if (flush) {
gst_aiurdemux_push_event (demux, gst_event_new_flush_start ());
}
gst_pad_pause_task (demux->sinkpad);
/* wait for streaming to finish */
GST_PAD_STREAM_LOCK (demux->sinkpad);
/* copy segment, we need this because we still need the old
* segment when we close the current segment. */
memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
if (event) {
gst_segment_do_seek (&seeksegment, rate, format, flags,
cur_type, cur, stop_type, stop, &update);
}
if (flush) {
gst_aiurdemux_push_event (demux, gst_event_new_flush_stop (TRUE));
}
/* now do the seek, this actually never returns FALSE */
ret =
gst_aiurdemux_perform_seek (demux, &seeksegment,
(flags & GST_SEEK_FLAG_ACCURATE));
/* commit the new segment */
memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
/* restart streaming, NEWSEGMENT will be sent from the streaming
* thread. */
for (i = 0; i < demux->n_streams; i++)
demux->streams[i]->last_ret = GST_FLOW_OK;
gst_pad_start_task (demux->sinkpad,
(GstTaskFunction) aiurdemux_pull_task, demux->sinkpad,NULL);
GST_PAD_STREAM_UNLOCK (demux->sinkpad);
g_mutex_unlock (&demux->seekmutex);
return ret;
/* ERRORS */
no_format:
{
GST_DEBUG_OBJECT (demux, "unsupported format given, seek aborted.");
return ret;
}
}
static gboolean
gst_aiurdemux_get_duration (GstAiurDemux * demux, gint64 * duration)
{
gboolean res = TRUE;
*duration = GST_CLOCK_TIME_NONE;
if (demux->movie_duration!= 0) {
if (demux->movie_duration != G_MAXINT64) {
*duration = demux->movie_duration;
}
}
return res;
}
static void
aiurdemux_send_pending_events (GstAiurDemux * demux)
{
guint n;
for (n = 0; n < demux->n_streams; n++) {
AiurDemuxStream *stream = demux->streams[n];
if (stream->pending_eos) {
aiurdemux_send_stream_eos (demux, stream);
}
}
}
static void
aiurdemux_release_resource (GstAiurDemux * demux)
{
int n;
for (n = 0; n < demux->n_streams; n++) {
AiurDemuxStream *stream = demux->streams[n];
if(stream == NULL){
continue;
}
if (stream->pad) {
gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad);
stream->pad = NULL;
}
if (stream->caps) {
gst_caps_unref (stream->caps);
stream->caps = NULL;
}
if (stream->pending_tags) {
gst_tag_list_unref (stream->pending_tags);
stream->pending_tags = NULL;
}
if (stream->buffer) {
gst_buffer_unref (stream->buffer);
stream->buffer = NULL;
}
if (stream->adapter) {
gst_adapter_clear (stream->adapter);
g_object_unref (stream->adapter);
stream->adapter = NULL;
}
if (stream->buf_queue) {
GstBuffer * gbuf;
while ((gbuf = g_queue_pop_head ((stream)->buf_queue))) {
gst_buffer_unref (gbuf);
};
g_queue_free (stream->buf_queue);
stream->buf_queue = NULL;
}
g_free (stream);
stream = NULL;
}
if (demux->programs) {
for (n = 0; n < demux->program_num; n++) {
AiurDemuxProgram *program = demux->programs[n];
if (program) {
g_free (program);
}
}
g_free (demux->programs);
demux->programs = NULL;
}
}
static GstFlowReturn
gst_aiurdemux_close_core (GstAiurDemux * demux)
{
int32 core_ret = PARSER_SUCCESS;
AiurCoreInterface *IParser = demux->core_interface;
FslParserHandle handle = demux->core_handle;
gchar * index_file = NULL;
if (IParser) {
if (handle) {
index_file = aiurcontent_get_index_file(demux->content_info);
if ((demux->option.index_enabled) &&(index_file)
&& (IParser->coreid) && (strlen (IParser->coreid))) {
uint32 size = 0;
AiurIndexTable *itab;
if (IParser->exportIndex) {
core_ret = IParser->exportIndex( handle, NULL, &size);
if (((core_ret != PARSER_SUCCESS) && (size <= 0))
|| (size > AIUR_IDX_TABLE_MAX_SIZE)) {
size = 0;
}
}
itab = aiurdemux_create_idx_table (size, IParser->coreid);
if (itab) {
if (size) {
core_ret = IParser->exportIndex(handle, itab->idx, &size);
if (core_ret != PARSER_SUCCESS) {
size = 0;
}
}
core_ret =
aiurdemux_export_idx_table (index_file, itab);
if (core_ret == 0)
GST_INFO ("Index table %s[size:%d] exported.",
index_file, size);
aiurdemux_destroy_idx_table (itab);
}
}
IParser->deleteParser(handle);
}
aiur_core_destroy_interface (IParser);
demux->core_interface = NULL;
}
return GST_FLOW_OK;
}