Skip to content

V
vlc
Commit 169dd181 authored by Francois Cartegnie's avatar Francois Cartegnie
Browse files
Options

stream_filter: smooth: remove legacy smooth filter 

Deprecated by adaptative, which is also now jammed by filter.
Drops specific MP4 forged smoo/stra hacks.
parent 30819e5d
Expand all Show whitespace changes
Inline Side-by-side
Showing with 34 additions and 2467 deletions
NEWS
View file @ 169dd181
......@@ -70,8 +70,8 @@ Demuxers:
* Support for Creative ADPCM/alaw/ulaw/S16L in VOC files
* Support for Creative ADPCM in AVI
* Directory Demux can now sort items, ignore extensions and hidden files
* Replaced httplive stream filter with new HLS demuxer, using the same core
as the DASH module
* Replaced httplive stream filter with new HLS demuxer, replaced smooth
stream filter with new Smooth demuxer, both using unified adaptive module
Stream filter:
* Added ARIB STD-B25 TS streams decoder
......@@ -177,6 +177,7 @@ Removed modules
* Atmo video filter
* QTCapture access module (use AVCapture instead)
* httplive (use adaptive instead)
* smooth (use adaptive instead)
* Gnome-VFS access module (i.e. Gnome 2.x)
......
modules/MODULES_LIST
View file @ 169dd181
......@@ -342,7 +342,6 @@ $Id$
* skins2: Skinnable interface, new generation
* smb: SMB shares access module
* smf: Standard MIDI file demuxer
* smooth: Microsoft Smooth Streaming input
* sndio: OpenBSD sndio audio output
* soxr: SoX Resampler library audio filter
* spatializer: A spatializer audio filter
......
modules/demux/mp4/libmp4.c
View file @ 169dd181
......@@ -675,66 +675,12 @@ static int MP4_ReadBox_tfrf( stream_t *p_stream, MP4_Box_t *p_box )
MP4_READBOX_EXIT( 1 );
}
static void MP4_FreeBox_stra( MP4_Box_t *p_box )
{
FREENULL( p_box->data.p_stra->CodecPrivateData );
}
static int MP4_ReadBox_stra( stream_t *p_stream, MP4_Box_t *p_box )
{
MP4_READBOX_ENTER( MP4_Box_data_stra_t, MP4_FreeBox_stra );
MP4_Box_data_stra_t *p_stra = p_box->data.p_stra;
uint8_t i_reserved;
VLC_UNUSED(i_reserved);
MP4_GET1BYTE( p_stra->i_es_cat );
MP4_GET1BYTE( i_reserved );
MP4_GET2BYTES( p_stra->i_track_ID );
MP4_GET4BYTES( p_stra->i_timescale );
MP4_GET8BYTES( p_stra->i_duration );
MP4_GET4BYTES( p_stra->FourCC );
MP4_GET4BYTES( p_stra->Bitrate );
MP4_GET4BYTES( p_stra->MaxWidth );
MP4_GET4BYTES( p_stra->MaxHeight );
MP4_GET4BYTES( p_stra->SamplingRate );
MP4_GET4BYTES( p_stra->Channels );
MP4_GET4BYTES( p_stra->BitsPerSample );
MP4_GET4BYTES( p_stra->AudioTag );
MP4_GET2BYTES( p_stra->nBlockAlign );
MP4_GET1BYTE( i_reserved );
MP4_GET1BYTE( i_reserved );
MP4_GET1BYTE( i_reserved );
MP4_GET1BYTE( p_stra->cpd_len );
if( p_stra->cpd_len > i_read )
goto error;
p_stra->CodecPrivateData = malloc( p_stra->cpd_len );
if( unlikely( p_stra->CodecPrivateData == NULL ) )
goto error;
memcpy( p_stra->CodecPrivateData, p_peek, p_stra->cpd_len );
#ifdef MP4_VERBOSE
msg_Dbg( p_stream, "es_cat is %"PRIu8", birate is %"PRIu32,
p_stra->i_es_cat, p_stra->Bitrate );
#endif
MP4_READBOX_EXIT( 1 );
error:
MP4_READBOX_EXIT( 0 );
}
static int MP4_ReadBox_uuid( stream_t *p_stream, MP4_Box_t *p_box )
{
if( !CmpUUID( &p_box->i_uuid, &TfrfBoxUUID ) )
return MP4_ReadBox_tfrf( p_stream, p_box );
if( !CmpUUID( &p_box->i_uuid, &TfxdBoxUUID ) )
return MP4_ReadBox_tfxd( p_stream, p_box );
if( !CmpUUID( &p_box->i_uuid, &SmooBoxUUID ) )
return MP4_ReadBoxContainer( p_stream, p_box );
if( !CmpUUID( &p_box->i_uuid, &StraBoxUUID ) )
return MP4_ReadBox_stra( p_stream, p_box );
msg_Warn( p_stream, "Unknown uuid type box" );
return 1;
......@@ -4102,39 +4048,6 @@ void MP4_BoxFree( MP4_Box_t *p_box )
free( p_box );
}
/* SmooBox is a very simple MP4 box, VLC specific, used only for the stream_filter to
* send information to the demux. SmooBox is actually a simplified moov box (we wanted
* to avoid the hassle of building a moov box at the stream_filter level) */
MP4_Box_t *MP4_BoxGetSmooBox( stream_t *s )
{
/* p_chunk is a virtual root container for the smoo box */
MP4_Box_t *p_chunk;
MP4_Box_t *p_smoo;
p_chunk = calloc( 1, sizeof( MP4_Box_t ) );
if( unlikely( p_chunk == NULL ) )
return NULL;
p_chunk->i_type = ATOM_root;
p_chunk->i_shortsize = 1;
p_smoo = MP4_ReadBox( s, p_chunk );
if( !p_smoo || p_smoo->i_type != ATOM_uuid || CmpUUID( &p_smoo->i_uuid, &SmooBoxUUID ) )
{
msg_Warn( s, "no smoo box found!");
goto error;
}
p_chunk->p_first = p_smoo;
p_chunk->p_last = p_smoo;
return p_chunk;
error:
free( p_chunk );
return NULL;
}
MP4_Box_t *MP4_BoxGetNextChunk( stream_t *s )
{
/* p_chunk is a virtual root container for the moof and mdat boxes */
......@@ -4148,12 +4061,7 @@ MP4_Box_t *MP4_BoxGetNextChunk( stream_t *s )
/* We might get a ftyp box or a SmooBox */
MP4_PeekBoxHeader( s, p_tmp_box );
if( (p_tmp_box->i_type == ATOM_uuid && !CmpUUID( &p_tmp_box->i_uuid, &SmooBoxUUID )) )
{
free( p_tmp_box );
return MP4_BoxGetSmooBox( s );
}
else if( p_tmp_box->i_type == ATOM_ftyp )
if( p_tmp_box->i_type == ATOM_ftyp )
{
free( p_tmp_box );
return MP4_BoxGetRoot( s );
......
modules/demux/mp4/libmp4.h
View file @ 169dd181
......@@ -1358,26 +1358,6 @@ typedef struct
uint8_t *p_sample_number;
} MP4_Box_data_tfra_t;
typedef struct
{
uint64_t i_duration;
uint32_t i_timescale;
uint16_t i_track_ID;
uint8_t i_es_cat;
uint32_t FourCC;
uint32_t Bitrate;
uint32_t MaxWidth;
uint32_t MaxHeight;
uint32_t SamplingRate;
uint32_t Channels;
uint32_t BitsPerSample;
uint32_t AudioTag;
uint16_t nBlockAlign;
uint8_t cpd_len;
uint8_t *CodecPrivateData;
} MP4_Box_data_stra_t;
typedef struct
{
enum
......@@ -1462,7 +1442,6 @@ typedef union MP4_Box_data_s
MP4_Box_data_tfra_t *p_tfra;
MP4_Box_data_mfro_t *p_mfro;
MP4_Box_data_stra_t *p_stra;
MP4_Box_data_stsz_t *p_stsz;
MP4_Box_data_stz2_t *p_stz2;
......@@ -1666,16 +1645,6 @@ static const UUID_t TfxdBoxUUID = {
{ 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2 } };
static const UUID_t SmooBoxUUID = {
{ 0xe1, 0xda, 0x72, 0xba, 0x24, 0xd7, 0x43, 0xc3,
0xa6, 0xa5, 0x1b, 0x57, 0x59, 0xa1, 0xa9, 0x2c } };
static const UUID_t StraBoxUUID = {
{ 0xb0, 0x3e, 0xf7, 0x70, 0x33, 0xbd, 0x4b, 0xac,
0x96, 0xc7, 0xbf, 0x25, 0xf9, 0x7e, 0x24, 0x47 } };
MP4_Box_t *MP4_BoxGetSmooBox( stream_t * );
/*****************************************************************************
* MP4_BoxGetNextChunk : Parse the entire moof box.
*****************************************************************************
......
modules/demux/mp4/mp4.c
View file @ 169dd181
This diff is collapsed.
modules/stream_filter/Makefile.am
View file @ 169dd181
......@@ -20,19 +20,6 @@ libprefetch_plugin_la_SOURCES = stream_filter/prefetch.c
libprefetch_plugin_la_LIBADD = $(LIBPTHREAD)
stream_filter_LTLIBRARIES += libprefetch_plugin.la
libsmooth_plugin_la_SOURCES = \
stream_filter/smooth/smooth.c \
stream_filter/smooth/utils.c \
stream_filter/smooth/downloader.c \
stream_filter/smooth/smooth.h \
demux/mp4/libmp4.c demux/mp4/libmp4.h
libsmooth_plugin_la_CFLAGS = $(AM_CFLAGS)
libsmooth_plugin_la_LIBADD = $(LIBM)
if HAVE_ZLIB
libsmooth_plugin_la_LIBADD += -lz
endif
stream_filter_LTLIBRARIES += libsmooth_plugin.la
libhds_plugin_la_SOURCES = \
stream_filter/hds/hds.c
......
modules/stream_filter/smooth/downloader.c deleted 100644 → 0
View file @ 30819e5d
This diff is collapsed.
modules/stream_filter/smooth/smooth.c deleted 100644 → 0
View file @ 30819e5d
This diff is collapsed.
modules/stream_filter/smooth/smooth.h deleted 100644 → 0
View file @ 30819e5d
/*****************************************************************************
* smooth.h: misc. stuff
*****************************************************************************
* Copyright (C) 1996-2012 VLC authors and VideoLAN
* $Id$
*
* Author: Frédéric Yhuel <fyhuel _AT_ viotech _DOT_ net>
*
* 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
*****************************************************************************/
#ifndef _VLC_SMOOTH_H
#define _VLC_SMOOTH_H 1
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <vlc_common.h>
#include <vlc_arrays.h>
//#define DISABLE_BANDWIDTH_ADAPTATION
#define CHUNK_OFFSET_UNSET 0
#define CHUNK_OFFSET_0 1
#define SMS_BW_SHORTSTATS 4
#define SMS_PROBE_LENGTH (CLOCK_FREQ * 2)
typedef struct chunk_s chunk_t;
struct chunk_s
{
uint64_t duration; /* chunk duration (seconds / TimeScale) */
uint64_t start_time; /* PTS (seconds / TimeScale) */
uint64_t size; /* chunk size in bytes */
uint64_t offset; /* offset in the media */
uint64_t read_pos; /* position in the chunk */
int type; /* video, audio, or subtitles */
uint8_t *data;
chunk_t *p_next;
};
typedef struct
{
char *psz_key;
char *psz_value;
} custom_attrs_t;
typedef struct quality_level_s
{
int Index;
uint32_t FourCC;
unsigned Bitrate;
unsigned MaxWidth;
unsigned MaxHeight;
unsigned SamplingRate;
unsigned Channels;
unsigned BitsPerSample;
unsigned AudioTag;
unsigned nBlockAlign;
char *CodecPrivateData; /* hex encoded string */
DECL_ARRAY(custom_attrs_t *) custom_attrs;
int64_t i_validation_length; /* how long did we experience that bitrate */
} quality_level_t;
typedef struct sms_stream_s
{
DECL_ARRAY( quality_level_t * ) qlevels; /* list of available Quality Levels */
chunk_t *p_chunks; /* Time Ordered list of chunks */
chunk_t *p_lastchunk; /* Time Ordered list of chunks's tail */
chunk_t *p_nextdownload; /* Pointer to next chunk to download */
chunk_t *p_playback; /* Pointer to current playback chunk */
vlc_mutex_t chunks_lock; /* chunks global lock */
uint32_t default_FourCC;
unsigned vod_chunks_nb; /* total num of chunks of the VOD stream */
unsigned timescale;
unsigned qlevel_nb; /* declared number of quality levels */
unsigned id; /* track id, will be set arbitrarily */
char *name;
char *url_template;
int type;
quality_level_t *current_qlvl; /* current quality level for Download() */
uint64_t rgi_bw[SMS_BW_SHORTSTATS]; /* Measured bandwidths of the N last chunks */
int rgi_tidx; /* tail index of rgi_bw */
uint64_t i_obw; /* Overwall bandwidth average */
unsigned int i_obw_samples; /* used to compute overall incrementally */
} sms_stream_t;
struct stream_sys_t
{
DECL_ARRAY( sms_stream_t * ) sms; /* available streams */
DECL_ARRAY( sms_stream_t * ) sms_selected; /* selected streams */
uint64_t vod_duration; /* total duration of the VOD media (seconds / TimeScale) */
uint64_t time_pos;
unsigned timescale;
int64_t i_probe_length; /* min duration before upgrading resolution */
/* Download */
struct
{
char *base_url; /* URL common part for chunks */
unsigned lookahead_count;/* max number of fragments ahead on server on live streaming */
vlc_thread_t thread; /* SMS chunk download thread */
vlc_cond_t wait; /* some condition to wait on */
} download;
/* Playback */
sms_stream_t *p_current_stream;
vlc_mutex_t lock;
struct
{
uint64_t boffset; /* current byte offset in media */
uint64_t next_chunk_offset;
struct
{
chunk_t *p_datachunk; /* the (re)init data chunk */
const chunk_t *p_startchunk; /* reinit must be sent before this one */
} init;
vlc_mutex_t lock;
vlc_cond_t wait; /* some condition to wait on */
} playback;
/* state */
bool b_live; /* live stream? or vod? */
};
#define SMS_GET_SELECTED_ST( cat ) \
sms_get_stream_by_cat( p_sys, cat )
void bw_stats_put( sms_stream_t *, const uint64_t );
uint64_t bw_stats_avg( sms_stream_t * );
void bw_stats_underrun( sms_stream_t * );
void* sms_Thread( void *);
quality_level_t * ql_New( void );
void ql_Free( quality_level_t *);
chunk_t *chunk_AppendNew( sms_stream_t* , uint64_t , uint64_t );
void chunk_Free( chunk_t *);
sms_stream_t * sms_New( void );
void sms_Free( sms_stream_t *);
uint8_t *decode_string_hex_to_binary( const char * );
sms_stream_t * sms_get_stream_by_cat( stream_sys_t *, int );
bool no_more_chunks( stream_sys_t * );
void resetChunksState( stream_sys_t * );
#endif
modules/stream_filter/smooth/utils.c deleted 100644 → 0
View file @ 30819e5d
/*****************************************************************************
* utils.c: misc. stuff
*****************************************************************************
* Copyright (C) 1996-2012 VLC authors and VideoLAN
* $Id$
*
* Author: Frédéric Yhuel <fyhuel _AT_ viotech _DOT_ net>
*
* 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
*****************************************************************************/
#include "smooth.h"
#include <vlc_es.h>
#include <vlc_block.h>
#include <assert.h>
static int hex_digit( const char c )
{
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
else if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
else if (c >= '0' && c<= '9')
return c - '0';
else
return -1;
}
uint8_t *decode_string_hex_to_binary( const char *psz_src )
{
int i = 0, j = 0, first_digit, second_digit;
int i_len = strlen( psz_src );
assert( i_len % 2 == 0 );
uint8_t *p_data = malloc( i_len / 2 );
if( !p_data )
return NULL;
while( i < i_len )
{
first_digit = hex_digit( psz_src[i++] );
second_digit = hex_digit( psz_src[i++] );
assert( first_digit >= 0 && second_digit >= 0 );
p_data[j++] = ( first_digit << 4 ) | second_digit;
}
return p_data;
}
quality_level_t * ql_New( void )
{
quality_level_t *ql = calloc( 1, sizeof( quality_level_t ) );
if( unlikely( !ql ) ) return NULL;
ql->Index = -1;
ARRAY_INIT(ql->custom_attrs);
return ql;
}
void ql_Free( quality_level_t *qlevel )
{
free( qlevel->CodecPrivateData );
FOREACH_ARRAY( custom_attrs_t *p_attrs, qlevel->custom_attrs )
free( p_attrs->psz_key );
free( p_attrs->psz_value );
FOREACH_END()
ARRAY_RESET(qlevel->custom_attrs);
free( qlevel );
qlevel = NULL;
}
chunk_t *chunk_AppendNew( sms_stream_t* sms, uint64_t duration,
uint64_t start_time )
{
chunk_t *chunk = calloc( 1, sizeof( chunk_t ) );
if( unlikely( chunk == NULL ) )
return NULL;
chunk->duration = duration;
chunk->start_time = start_time;
chunk->type = UNKNOWN_ES;
if ( sms->p_lastchunk )
{
assert(sms->p_chunks);
sms->p_lastchunk->p_next = chunk;
}
else
{
assert(!sms->p_chunks);
sms->p_chunks = chunk;
/* Everything starts from first chunk */
sms->p_nextdownload = chunk;
sms->p_playback = chunk;
}
sms->p_lastchunk = chunk;
return chunk;
}
void chunk_Free( chunk_t *chunk )
{
free( chunk->data );
free( chunk );
}
sms_stream_t * sms_New( void )
{
sms_stream_t *sms = calloc( 1, sizeof( sms_stream_t ) );
if( unlikely( !sms ) ) return NULL;
ARRAY_INIT( sms->qlevels );
sms->type = UNKNOWN_ES;
vlc_mutex_init( &sms->chunks_lock );
return sms;
}
void sms_Free( sms_stream_t *sms )
{
if ( !sms )
return;
FOREACH_ARRAY( quality_level_t *qlevel, sms->qlevels );
if( qlevel )
ql_Free( qlevel );
FOREACH_END();
ARRAY_RESET( sms->qlevels );
vlc_mutex_lock( &sms->chunks_lock );
while( sms->p_chunks )
{
chunk_t *p_chunk = sms->p_chunks;
sms->p_chunks = sms->p_chunks->p_next;
chunk_Free( p_chunk );
}
vlc_mutex_unlock( &sms->chunks_lock );
vlc_mutex_destroy( &sms->chunks_lock );
free( sms->name );
free( sms->url_template );
free( sms );
}
void bw_stats_put( sms_stream_t *sms, const uint64_t bw )
{
/* overall bw update */
if ( bw >= sms->i_obw )
sms->i_obw = sms->i_obw + ( bw - sms->i_obw ) /
(sms->i_obw_samples + 1);
else
sms->i_obw = sms->i_obw - ( sms->i_obw - bw ) /
(sms->i_obw_samples + 1);
sms->i_obw_samples++;
/* limited history bw stats update */
if ( sms->rgi_bw[0] == 0 )
{ /* first stats */
for( int i=0; i<SMS_BW_SHORTSTATS; i++ )
sms->rgi_bw[i] = bw;
}
else
{
sms->rgi_tidx = (sms->rgi_tidx + 1) % SMS_BW_SHORTSTATS;
sms->rgi_bw[sms->rgi_tidx] = bw;
}
}
uint64_t bw_stats_avg( sms_stream_t *sms )
{
uint64_t sum = sms->rgi_bw[0];
for( int i=1; i<SMS_BW_SHORTSTATS; i++ )
sum += sms->rgi_bw[i];
return sum / SMS_BW_SHORTSTATS;
}
void bw_stats_underrun( sms_stream_t *sms )
{
sms->i_obw = bw_stats_avg( sms );
sms->i_obw_samples = SMS_BW_SHORTSTATS;
}
sms_stream_t * sms_get_stream_by_cat( stream_sys_t *p_sys, int i_cat )
{
assert( p_sys->sms_selected.i_size >= 0 && p_sys->sms_selected.i_size <= 3 );
FOREACH_ARRAY( sms_stream_t *sms, p_sys->sms_selected );
if( sms->type == i_cat )
return sms;
FOREACH_END();
return NULL;
}
bool no_more_chunks( stream_sys_t *p_sys )
{
FOREACH_ARRAY( sms_stream_t *sms, p_sys->sms_selected );
if ( sms->p_playback )
{
return false;
}
FOREACH_END();
return true;
}
void resetChunksState( stream_sys_t *p_sys )
{
FOREACH_ARRAY( sms_stream_t *sms, p_sys->sms_selected );
vlc_mutex_lock( &sms->chunks_lock );
chunk_t *p_chunk = sms->p_playback;
while( p_chunk )
{
FREENULL( p_chunk->data );
p_chunk->offset = CHUNK_OFFSET_UNSET;
p_chunk->size = 0;
p_chunk->read_pos = 0;
if ( p_chunk == sms->p_nextdownload )
break;
p_chunk = p_chunk->p_next;
}
sms->p_playback = NULL;
sms->p_nextdownload = NULL;
vlc_mutex_unlock( &sms->chunks_lock );
FOREACH_END();
}
po/POTFILES.in
View file @ 169dd181
......@@ -1038,7 +1038,6 @@ modules/stream_filter/decomp.c
modules/stream_filter/hds/hds.c
modules/stream_filter/prefetch.c
modules/stream_filter/record.c
modules/stream_filter/smooth/smooth.c
modules/stream_out/autodel.c
modules/stream_out/bridge.c
modules/stream_out/cycle.c
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment