* Preamble
*****************************************************************************/
-#include <vlc/vlc.h>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
-#include <stdio.h>
#include <vlc_demux.h>
-#include <vlc_playlist.h>
#include <vlc_md5.h>
#include <vlc_charset.h>
-#include "iso_lang.h"
+#include <vlc_iso_lang.h>
#include <vlc_meta.h>
+#include <vlc_input.h>
#include "libmp4.h"
#include "drms.h"
vlc_module_begin();
set_category( CAT_INPUT );
set_subcategory( SUBCAT_INPUT_DEMUX );
- set_description( _("MP4 stream demuxer") );
- set_capability( "demux2", 242 );
+ set_description( N_("MP4 stream demuxer") );
+ set_capability( "demux", 242 );
set_callbacks( Open, Close );
vlc_module_end();
* Local prototypes
*****************************************************************************/
static int Demux ( demux_t * );
-static int DemuxRef( demux_t *p_demux ){ return 0;}
+static int DemuxRef( demux_t *p_demux ){ (void)p_demux; return 0;}
static int Seek ( demux_t *, mtime_t );
static int Control ( demux_t *, int, va_list );
int b_ok; /* The track is usable */
int b_enable; /* is the trak enable by default */
- vlc_bool_t b_selected; /* is the trak being played */
- vlc_bool_t b_chapter; /* True when used for chapter only */
+ bool b_selected; /* is the trak being played */
+ bool b_chapter; /* True when used for chapter only */
es_format_t fmt;
es_out_id_t *p_es;
MP4_Box_t *p_stsd; /* will contain all data to initialize decoder */
MP4_Box_t *p_sample;/* point on actual sdsd */
- vlc_bool_t b_drms;
+ bool b_drms;
void *p_drms;
} mp4_track_t;
* Declaration of local function
*****************************************************************************/
static void MP4_TrackCreate ( demux_t *, mp4_track_t *, MP4_Box_t *);
-static void MP4_TrackDestroy( demux_t *, mp4_track_t * );
+static void MP4_TrackDestroy( mp4_track_t * );
static int MP4_TrackSelect ( demux_t *, mp4_track_t *, mtime_t );
static void MP4_TrackUnselect(demux_t *, mp4_track_t * );
if( i_dts < 0 ) i_dts = 0;
}
- return I64C(1000000) * i_dts / p_track->i_timescale;
+ return INT64_C(1000000) * i_dts / p_track->i_timescale;
}
-static inline int64_t MP4_TrackGetPTSDelta( demux_t *p_demux, mp4_track_t *p_track )
+static inline int64_t MP4_TrackGetPTSDelta( mp4_track_t *p_track )
{
mp4_chunk_t *ck = &p_track->chunk[p_track->i_chunk];
unsigned int i_index = 0;
for( i_index = 0;; i_index++ )
{
if( i_sample < ck->p_sample_count_pts[i_index] )
- return ck->p_sample_offset_pts[i_index] * I64C(1000000) /
+ return ck->p_sample_offset_pts[i_index] * INT64_C(1000000) /
(int64_t)p_track->i_timescale;
i_sample -= ck->p_sample_count_pts[i_index];
static inline int64_t MP4_GetMoviePTS(demux_sys_t *p_sys )
{
- return I64C(1000000) * p_sys->i_time / p_sys->i_timescale;
+ return INT64_C(1000000) * p_sys->i_time / p_sys->i_timescale;
}
-/* Function to lookup the currently playing item */
-static vlc_bool_t FindItem( demux_t *p_demux, playlist_t *p_playlist,
- playlist_item_t **pp_item );
-
static void LoadChapter( demux_t *p_demux );
/*****************************************************************************
MP4_Box_t *p_trak;
unsigned int i;
- vlc_bool_t b_seekable;
+ bool b_seekable;
/* A little test to see if it could be a mp4 */
if( stream_Peek( p_demux->s, &p_peek, 8 ) < 8 ) return VLC_EGENERIC;
if( ( p_rmra = MP4_BoxGet( p_sys->p_root, "/moov/rmra" ) ) )
{
- playlist_t *p_playlist;
- playlist_item_t *p_current, *p_item_in_category;
int i_count = MP4_BoxCount( p_rmra, "rmda" );
int i;
- vlc_bool_t b_play = VLC_FALSE;
msg_Dbg( p_demux, "detected playlist mov file (%d ref)", i_count );
- p_playlist = pl_Yield( p_demux );
- if( p_playlist )
+ input_thread_t * p_input = vlc_object_find( p_demux, VLC_OBJECT_INPUT, FIND_PARENT );
+ input_item_t * p_current = input_GetItem( p_input );
+ p_current->i_type = ITEM_TYPE_PLAYLIST;
+
+ for( i = 0; i < i_count; i++ )
{
- b_play = FindItem( p_demux, p_playlist, &p_current );
- p_item_in_category = playlist_ItemToNode( p_playlist, p_current, VLC_TRUE );
- p_current->p_input->i_type = ITEM_TYPE_PLAYLIST;
+ MP4_Box_t *p_rdrf = MP4_BoxGet( p_rmra, "rmda[%d]/rdrf", i );
+ char *psz_ref;
+ uint32_t i_ref_type;
- for( i = 0; i < i_count; i++ )
+ if( !p_rdrf || !( psz_ref = strdup( p_rdrf->data.p_rdrf->psz_ref ) ) )
{
- MP4_Box_t *p_rdrf = MP4_BoxGet( p_rmra, "rmda[%d]/rdrf", i );
- char *psz_ref;
- uint32_t i_ref_type;
+ continue;
+ }
+ i_ref_type = p_rdrf->data.p_rdrf->i_ref_type;
- if( !p_rdrf || !( psz_ref = strdup( p_rdrf->data.p_rdrf->psz_ref ) ) )
+ msg_Dbg( p_demux, "new ref=`%s' type=%4.4s",
+ psz_ref, (char*)&i_ref_type );
+
+ if( i_ref_type == VLC_FOURCC( 'u', 'r', 'l', ' ' ) )
+ {
+ if( strstr( psz_ref, "qt5gateQT" ) )
{
+ msg_Dbg( p_demux, "ignoring pseudo ref =`%s'", psz_ref );
continue;
}
- i_ref_type = p_rdrf->data.p_rdrf->i_ref_type;
-
- msg_Dbg( p_demux, "new ref=`%s' type=%4.4s",
- psz_ref, (char*)&i_ref_type );
-
- if( i_ref_type == VLC_FOURCC( 'u', 'r', 'l', ' ' ) )
+ if( !strncmp( psz_ref, "http://", 7 ) ||
+ !strncmp( psz_ref, "rtsp://", 7 ) )
{
- if( strstr( psz_ref, "qt5gateQT" ) )
- {
- msg_Dbg( p_demux, "ignoring pseudo ref =`%s'", psz_ref );
- continue;
- }
- if( !strncmp( psz_ref, "http://", 7 ) ||
- !strncmp( psz_ref, "rtsp://", 7 ) )
- {
- ;
- }
- else
- {
- char *psz_absolute;
- char *psz_path = strdup( p_demux->psz_path );
- char *end = strrchr( psz_path, '/' );
- if( end ) end[1] = '\0';
- else *psz_path = '\0';
-
- asprintf( &psz_absolute, "%s://%s%s",
- p_demux->psz_access, psz_path, psz_ref );
-
- if( psz_ref ) free( psz_ref );
- psz_ref = psz_absolute;
- free( psz_path );
- }
- if( p_current )
- {
- input_item_t *p_input;
- msg_Dbg( p_demux, "adding ref = `%s'", psz_ref );
- p_input = input_ItemNewExt( p_playlist, psz_ref, NULL,
- 0, NULL, -1 );
- input_ItemCopyOptions( p_current->p_input, p_input );
- playlist_BothAddInput( p_playlist, p_input,
- p_item_in_category,
- PLAYLIST_APPEND, PLAYLIST_END,
- NULL, NULL, VLC_FALSE );
- }
+ ;
}
else
{
- msg_Err( p_demux, "unknown ref type=%4.4s FIXME (send a bug report)",
- (char*)&p_rdrf->data.p_rdrf->i_ref_type );
+ char *psz_absolute;
+ char *psz_path = strdup( p_demux->psz_path );
+ char *end = strrchr( psz_path, '/' );
+ if( end ) end[1] = '\0';
+ else *psz_path = '\0';
+
+ if( asprintf( &psz_absolute, "%s://%s%s",
+ p_demux->psz_access, psz_path, psz_ref ) < 0 )
+ return VLC_ENOMEM;
+
+ free( psz_ref );
+ psz_ref = psz_absolute;
+ free( psz_path );
}
- if( psz_ref ) free( psz_ref );
+ input_item_t *p_input;
+ msg_Dbg( p_demux, "adding ref = `%s'", psz_ref );
+ p_input = input_ItemNewExt( p_demux, psz_ref, NULL,
+ 0, NULL, -1 );
+ input_ItemCopyOptions( p_current, p_input );
+ input_ItemAddSubItem( p_current, p_input );
+ vlc_gc_decref( p_input );
}
- if( b_play && p_item_in_category &&
- p_item_in_category->i_children > 0 )
+ else
{
- playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, VLC_TRUE,
- p_item_in_category, NULL );
+ msg_Err( p_demux, "unknown ref type=%4.4s FIXME (send a bug report)",
+ (char*)&p_rdrf->data.p_rdrf->i_ref_type );
}
- vlc_object_release( p_playlist );
- }
- else
- {
- msg_Err( p_demux, "can't find playlist" );
+ free( psz_ref );
}
+ vlc_object_release( p_input );
}
if( !(p_mvhd = MP4_BoxGet( p_sys->p_root, "/moov/mvhd" ) ) )
else
{
p_sys->i_timescale = p_mvhd->data.p_mvhd->i_timescale;
+ if( p_sys->i_timescale == 0 )
+ {
+ msg_Err( p_this, "bad timescale" );
+ goto error;
+ }
p_sys->i_duration = p_mvhd->data.p_mvhd->i_duration;
}
msg_Err( p_demux, "cannot find any /moov/trak" );
goto error;
}
- msg_Dbg( p_demux, "find %d track%c",
+ msg_Dbg( p_demux, "found %d track%c",
p_sys->i_tracks,
p_sys->i_tracks ? 's':' ' );
/* allocate memory */
p_sys->track = calloc( p_sys->i_tracks, sizeof( mp4_track_t ) );
+ if( p_sys->track == NULL )
+ goto error;
memset( p_sys->track, 0, p_sys->i_tracks * sizeof( mp4_track_t ) );
/* Search the first chap reference (like quicktime) */
i_track++ )
{
mp4_track_t *tk = &p_sys->track[i_track];
- vlc_bool_t b;
+ bool b;
if( !tk->b_ok || tk->b_chapter ||
( tk->b_selected && tk->i_sample >= tk->i_sample_count ) )
/* dts */
p_block->i_dts = MP4_TrackGetDTS( p_demux, tk ) + 1;
/* pts */
- i_delta = MP4_TrackGetPTSDelta( p_demux, tk );
+ i_delta = MP4_TrackGetPTSDelta( tk );
if( i_delta != -1 )
p_block->i_pts = p_block->i_dts + i_delta;
else if( tk->fmt.i_cat != VIDEO_ES )
SET( vlc_meta_SetAlbum );
break;
+ case FOURCC_0xa9trk: /* Track */
+ SET( vlc_meta_SetTracknum );
+ break;
+
+ case FOURCC_0xa9cmt: /* Commment */
+ SET( vlc_meta_SetDescription );
+ break;
+
+ case FOURCC_0xa9url: /* URL */
+ SET( vlc_meta_SetURL );
+ break;
+
+ case FOURCC_0xa9enc: /* Encoded By */
+ SET( vlc_meta_SetEncodedBy );
+ break;
+
case FOURCC_0xa9swr:
case FOURCC_0xa9inf: /* Information */
case FOURCC_0xa9dir: /* Director */
case FOURCC_0xa9dis: /* Disclaimer */
- case FOURCC_0xa9enc: /* Encoded By */
- case FOURCC_0xa9trk: /* Track */
- case FOURCC_0xa9cmt: /* Commment */
- case FOURCC_0xa9url: /* URL */
case FOURCC_0xa9req: /* Requirements */
case FOURCC_0xa9fmt: /* Original Format */
case FOURCC_0xa9dsa: /* Display Source As */
case DEMUX_SET_NEXT_DEMUX_TIME:
case DEMUX_SET_GROUP:
+ case DEMUX_HAS_UNSUPPORTED_META:
+ case DEMUX_GET_ATTACHMENTS:
return VLC_EGENERIC;
default:
MP4_BoxFree( p_demux->s, p_sys->p_root );
for( i_track = 0; i_track < p_sys->i_tracks; i_track++ )
{
- MP4_TrackDestroy( p_demux, &p_sys->track[i_track] );
+ MP4_TrackDestroy( &p_sys->track[i_track] );
}
FREENULL( p_sys->track );
for( tk->i_sample = 0; tk->i_sample < tk->i_sample_count; tk->i_sample++ )
{
const int64_t i_dts = MP4_TrackGetDTS( p_demux, tk );
- const int64_t i_pts_delta = MP4_TrackGetPTSDelta( p_demux, tk );
+ const int64_t i_pts_delta = MP4_TrackGetPTSDelta( tk );
const unsigned int i_size = MP4_TrackSampleSize( tk );
if( i_size > 0 && !stream_Seek( p_demux->s, MP4_TrackGetPos( tk ) ) )
}
p_demux_track->chunk = calloc( p_demux_track->i_chunk_count,
sizeof( mp4_chunk_t ) );
+ if( p_demux_track->chunk == NULL )
+ {
+ return VLC_ENOMEM;
+ }
/* first we read chunk offset */
for( i_chunk = 0; i_chunk < p_demux_track->i_chunk_count; i_chunk++ )
for( i_chunk = p_stsc->data.p_stsc->i_first_chunk[i_index] - 1;
i_chunk < i_last; i_chunk++ )
{
+ if( i_chunk >= p_demux_track->i_chunk_count )
+ {
+ msg_Warn( p_demux, "corrupted chunk table" );
+ return VLC_EGENERIC;
+ }
+
p_demux_track->chunk[i_chunk].i_sample_description_index =
p_stsc->data.p_stsc->i_sample_description_index[i_index];
p_demux_track->chunk[i_chunk].i_sample_count =
p_demux_track->i_sample_size = 0;
p_demux_track->p_sample_size =
calloc( p_demux_track->i_sample_count, sizeof( uint32_t ) );
+ if( p_demux_track->p_sample_size == NULL )
+ return VLC_ENOMEM;
for( i_sample = 0; i_sample < p_demux_track->i_sample_count; i_sample++ )
{
}
}
- msg_Dbg( p_demux, "track[Id 0x%x] read %d samples length:"I64Fd"s",
+ msg_Dbg( p_demux, "track[Id 0x%x] read %d samples length:%"PRId64"s",
p_demux_track->i_track_ID, p_demux_track->i_sample_count,
i_last_dts / p_demux_track->i_timescale );
p_track->p_sample = p_sample;
- if( p_track->fmt.i_cat == AUDIO_ES && p_track->i_sample_size == 1 )
+ if( p_track->fmt.i_cat == AUDIO_ES && ( p_track->i_sample_size == 1 || p_track->i_sample_size == 2 ) )
{
MP4_Box_data_sample_soun_t *p_soun;
case VLC_FOURCC( 'u', 'l', 'a', 'w' ):
p_soun->i_samplesize = 8;
break;
+ case VLC_FOURCC( 'N', 'O', 'N', 'E' ):
+ case VLC_FOURCC( 'r', 'a', 'w', ' ' ):
+ case VLC_FOURCC( 't', 'w', 'o', 's' ):
+ case VLC_FOURCC( 's', 'o', 'w', 't' ):
+ /* What would be the fun if you could trust the .mov */
+ p_track->i_sample_size = ((p_soun->i_samplesize+7)/8) * p_soun->i_channelcount;
+ break;
default:
break;
}
}
}
-
/* It's a little ugly but .. there are special cases */
switch( p_sample->i_type )
{
break;
case( VLC_FOURCC( 'r', 'a', 'w', ' ' ) ):
- p_track->fmt.i_codec = VLC_FOURCC( 'a', 'r', 'a', 'w' );
+ case( VLC_FOURCC( 'N', 'O', 'N', 'E' ) ):
+ {
+ MP4_Box_data_sample_soun_t *p_soun = p_sample->data.p_sample_soun;
+
+ if(p_soun && (p_soun->i_samplesize+7)/8 == 1 )
+ p_track->fmt.i_codec = VLC_FOURCC( 'u', '8', ' ', ' ' );
+ else
+ p_track->fmt.i_codec = VLC_FOURCC( 't', 'w', 'o', 's' );
/* Buggy files workaround */
if( p_sample->data.p_sample_soun && (p_track->i_timescale !=
MP4_Box_data_sample_soun_t *p_soun =
p_sample->data.p_sample_soun;
- msg_Warn( p_demux, "i_timescale ("I64Fu") != i_sampleratehi "
+ msg_Warn( p_demux, "i_timescale (%"PRIu64") != i_sampleratehi "
"(%u), making both equal (report any problem).",
p_track->i_timescale, p_soun->i_sampleratehi );
p_soun->i_sampleratehi = p_track->i_timescale;
}
break;
+ }
case( VLC_FOURCC( 's', '2', '6', '3' ) ):
p_track->fmt.i_codec = VLC_FOURCC( 'h', '2', '6', '3' );
switch( p_sample->i_type )
{
/* qt decoder, send the complete chunk */
+ case VLC_FOURCC ('h', 'd', 'v', '1'): // HDV 720p30
+ case VLC_FOURCC ('h', 'd', 'v', '2'): // HDV 1080i60
+ case VLC_FOURCC ('h', 'd', 'v', '3'): // HDV 1080i50
+ case VLC_FOURCC ('h', 'd', 'v', '5'): // HDV 720p25
+ case VLC_FOURCC ('m', 'x', '5', 'n'): // MPEG2 IMX NTSC 525/60 50mb/s produced by FCP
+ case VLC_FOURCC ('m', 'x', '5', 'p'): // MPEG2 IMX PAL 625/60 50mb/s produced by FCP
+ case VLC_FOURCC ('m', 'x', '4', 'n'): // MPEG2 IMX NTSC 525/60 40mb/s produced by FCP
+ case VLC_FOURCC ('m', 'x', '4', 'p'): // MPEG2 IMX PAL 625/60 40mb/s produced by FCP
+ case VLC_FOURCC ('m', 'x', '3', 'n'): // MPEG2 IMX NTSC 525/60 30mb/s produced by FCP
+ case VLC_FOURCC ('m', 'x', '3', 'p'): // MPEG2 IMX PAL 625/50 30mb/s produced by FCP
+ case VLC_FOURCC ('x', 'd', 'v', '2'): // XDCAM HD 1080i60
+ case VLC_FOURCC ('A', 'V', 'm', 'p'): // AVID IMX PAL
+ p_track->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
+ break;
+ /* qt decoder, send the complete chunk */
case VLC_FOURCC( 'S', 'V', 'Q', '3' ):
case VLC_FOURCC( 'S', 'V', 'Q', '1' ):
case VLC_FOURCC( 'V', 'P', '3', '1' ):
break;
}
+ case VLC_FOURCC('m','s',0x00,0x02):
+ case VLC_FOURCC('m','s',0x00,0x11):
+ p_track->fmt.audio.i_blockalign = p_sample->data.p_sample_soun->i_bytes_per_frame;
+ break;
+
default:
break;
}
/* now calculate i_start for this elst */
/* offset */
- i_start -= p_track->i_elst_time * I64C(1000000) / p_sys->i_timescale;
+ i_start -= p_track->i_elst_time * INT64_C(1000000) / p_sys->i_timescale;
if( i_start < 0 )
{
*pi_chunk = 0;
i_start += elst->i_media_time[p_track->i_elst];
}
- msg_Dbg( p_demux, "elst (%d) gives "I64Fd"ms (movie)-> "I64Fd
+ msg_Dbg( p_demux, "elst (%d) gives %"PRId64"ms (movie)-> %"PRId64
"ms (track)", p_track->i_elst,
i_mvt * 1000 / p_sys->i_timescale,
i_start * 1000 / p_track->i_timescale );
static int TrackGotoChunkSample( demux_t *p_demux, mp4_track_t *p_track,
unsigned int i_chunk, unsigned int i_sample )
{
- vlc_bool_t b_reselect = VLC_FALSE;
+ bool b_reselect = false;
/* now see if actual es is ok */
if( (p_track->i_chunk >= p_track->i_chunk_count - 1) ||
msg_Err( p_demux, "cannot create es for track[Id 0x%x]",
p_track->i_track_ID );
- p_track->b_ok = VLC_FALSE;
- p_track->b_selected = VLC_FALSE;
+ p_track->b_ok = false;
+ p_track->b_selected = false;
return VLC_EGENERIC;
}
}
/* hint track unsupported */
/* set default value (-> track unusable) */
- p_track->b_ok = VLC_FALSE;
- p_track->b_enable = VLC_FALSE;
- p_track->b_selected = VLC_FALSE;
- p_track->b_chapter = VLC_FALSE;
+ p_track->b_ok = false;
+ p_track->b_enable = false;
+ p_track->b_selected = false;
+ p_track->b_chapter = false;
es_format_Init( &p_track->fmt, UNKNOWN_ES, 0 );
/* do we launch this track by default ? */
p_track->b_enable =
( ( p_tkhd->data.p_tkhd->i_flags&MP4_TRACK_ENABLED ) != 0 );
+ if( !p_track->b_enable )
+ p_track->fmt.i_priority = -1;
p_track->i_track_ID = p_tkhd->data.p_tkhd->i_track_ID;
p_track->i_width = p_tkhd->data.p_tkhd->i_width / 65536;
}
p_track->i_timescale = p_mdhd->data.p_mdhd->i_timescale;
+ if( !p_track->i_timescale )
+ return;
for( i = 0; i < 3; i++ )
{
msg_Warn( p_demux, "elst box found" );
for( i = 0; i < elst->i_entry_count; i++ )
{
- msg_Dbg( p_demux, " - [%d] duration="I64Fd"ms media time="I64Fd
+ msg_Dbg( p_demux, " - [%d] duration=%"PRId64"ms media time=%"PRId64
"ms) rate=%d.%d", i,
elst->i_segment_duration[i] * 1000 / p_sys->i_timescale,
elst->i_media_time[i] >= 0 ?
(int64_t)(elst->i_media_time[i] * 1000 / p_track->i_timescale) :
- I64C(-1),
+ INT64_C(-1),
elst->i_media_rate_integer[i],
elst->i_media_rate_fraction[i] );
}
{
if( p_track->i_track_ID == p_chap->i_track_ID[i] )
{
- p_track->b_chapter = VLC_TRUE;
+ p_track->b_chapter = true;
break;
}
}
p_track->i_track_ID );
return;
}
- p_track->b_ok = VLC_TRUE;
+ p_track->b_ok = true;
#if 0
{
int i;
****************************************************************************
* Destroy a track created by MP4_TrackCreate.
****************************************************************************/
-static void MP4_TrackDestroy( demux_t *p_demux, mp4_track_t *p_track )
+static void MP4_TrackDestroy( mp4_track_t *p_track )
{
unsigned int i_chunk;
- p_track->b_ok = VLC_FALSE;
- p_track->b_enable = VLC_FALSE;
- p_track->b_selected = VLC_FALSE;
+ p_track->b_ok = false;
+ p_track->b_enable = false;
+ p_track->b_selected = false;
es_format_Clean( &p_track->fmt );
if( p_track->p_es )
{
es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE,
- p_track->p_es, VLC_FALSE );
+ p_track->p_es, false );
}
- p_track->b_selected = VLC_FALSE;
+ p_track->b_selected = false;
}
static int MP4_TrackSeek( demux_t *p_demux, mp4_track_t *p_track,
if( !p_track->b_ok || p_track->b_chapter )
return VLC_EGENERIC;
- p_track->b_selected = VLC_FALSE;
+ p_track->b_selected = false;
if( TrackTimeToSampleChunk( p_demux, p_track, i_start,
&i_chunk, &i_sample ) )
return VLC_EGENERIC;
}
- p_track->b_selected = VLC_TRUE;
+ p_track->b_selected = true;
if( TrackGotoChunkSample( p_demux, p_track, i_chunk, i_sample ) ==
VLC_SUCCESS )
{
- p_track->b_selected = VLC_TRUE;
+ p_track->b_selected = true;
es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME,
p_track->p_es, i_start );
/*
* 3 types: for audio
- *
+ *
*/
#define QT_V0_MAX_SAMPLES 1024
static int MP4_TrackSampleSize( mp4_track_t *p_track )
msg_Warn( p_demux, "elst old=%d new=%d", i_elst_last, tk->i_elst );
}
}
-
-static vlc_bool_t FindItem( demux_t *p_demux, playlist_t *p_playlist,
- playlist_item_t **pp_item )
-{
- input_thread_t *p_input = (input_thread_t *)vlc_object_find( p_demux, VLC_OBJECT_INPUT, FIND_PARENT );
- vlc_bool_t b_play = var_CreateGetBool( p_demux, "playlist-autostart" );
-
- *pp_item = NULL;
- if( p_input )
- {
- if( b_play && p_playlist->status.p_item &&
- p_playlist->status.p_item->p_input == input_GetItem(p_input) )
- {
- msg_Dbg( p_playlist, "starting playlist playback" );
- *pp_item = p_playlist->status.p_item;
- b_play = VLC_TRUE;
- }
- else
- {
- input_item_t *p_current = input_GetItem( p_input );
-
- *pp_item = playlist_ItemGetByInput( p_playlist, p_current, VLC_FALSE );
- if( !*pp_item )
- msg_Dbg( p_playlist, "unable to find item in playlist");
-
- msg_Dbg( p_playlist, "not starting playlist playback");
- b_play = VLC_FALSE;
- }
- vlc_object_release( p_input );
- }
- return b_play;
-}
-
-
projects / vlc / blobdiff