copy.c 7.58 KB
Newer Older
1 2 3
/*****************************************************************************
 * copy.c
 *****************************************************************************
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
4
 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
5
 * $Id$
6 7 8 9
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Eric Petit <titer@videolan.org>
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
10 11 12
 * This program 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
13 14 15 16
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
17 18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
19
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
20 21 22
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 24 25 26 27
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
28

29 30 31 32
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

33
#include <vlc_common.h>
34
#include <vlc_plugin.h>
Clément Stenac's avatar
Clément Stenac committed
35 36
#include <vlc_codec.h>
#include <vlc_block.h>
37
#include <vlc_bits.h>
38 39 40 41

/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
42 43
static int  Open ( vlc_object_t * );
static void Close( vlc_object_t * );
44

45 46 47 48 49 50 51
vlc_module_begin ()
    set_category( CAT_SOUT )
    set_subcategory( SUBCAT_SOUT_PACKETIZER )
    set_description( N_("Copy packetizer") )
    set_capability( "packetizer", 1 )
    set_callbacks( Open, Close )
vlc_module_end ()
52

53 54 55
/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
56
struct decoder_sys_t
57
{
58
    block_t *p_block;
59
    void (*pf_parse)( decoder_t *, block_t * );
60
};
61

62 63
static block_t *Packetize   ( decoder_t *, block_t ** );
static block_t *PacketizeSub( decoder_t *, block_t ** );
64
static void Flush( decoder_t * );
65

66 67
static void ParseWMV3( decoder_t *, block_t * );

68
/*****************************************************************************
69
 * Open: probe the packetizer and return score
70 71 72 73 74 75
 *****************************************************************************
 * Tries to launch a decoder and return score so that the interface is able
 * to choose.
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
76 77
    decoder_t     *p_dec = (decoder_t*)p_this;
    decoder_sys_t *p_sys;
78

79 80 81
    if( p_dec->fmt_in.i_cat != AUDIO_ES &&
        p_dec->fmt_in.i_cat != VIDEO_ES &&
        p_dec->fmt_in.i_cat != SPU_ES )
82
    {
83 84
        msg_Err( p_dec, "invalid ES type" );
        return VLC_EGENERIC;
85 86
    }

87 88 89 90
    if( p_dec->fmt_in.i_cat == SPU_ES )
        p_dec->pf_packetize = PacketizeSub;
    else
        p_dec->pf_packetize = Packetize;
91
    p_dec->pf_flush = Flush;
92

93
    /* Create the output format */
94
    es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
95

96 97
    /* Fix the value of the fourcc for audio */
    if( p_dec->fmt_in.i_cat == AUDIO_ES )
98
    {
99 100 101 102 103 104 105
        p_dec->fmt_out.i_codec = vlc_fourcc_GetCodecAudio( p_dec->fmt_in.i_codec,
                                                           p_dec->fmt_in.audio.i_bitspersample );
        if( !p_dec->fmt_out.i_codec )
        {
            msg_Err( p_dec, "unknown raw audio sample size" );
            return VLC_EGENERIC;
        }
106
    }
107

108
    p_dec->p_sys = p_sys = malloc( sizeof(*p_sys) );
109
    p_sys->p_block    = NULL;
110 111 112 113 114 115 116 117 118
    switch( p_dec->fmt_in.i_codec )
    {
    case VLC_CODEC_WMV3:
        p_sys->pf_parse = ParseWMV3;
        break;
    default:
        p_sys->pf_parse = NULL;
        break;
    }
119

120 121
    return VLC_SUCCESS;
}
122

123 124 125 126 127 128
/*****************************************************************************
 * Close:
 *****************************************************************************/
static void Close( vlc_object_t *p_this )
{
    decoder_t     *p_dec = (decoder_t*)p_this;
129

130
    if( p_dec->p_sys->p_block )
131
    {
132
        block_ChainRelease( p_dec->p_sys->p_block );
133
    }
134

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
135
    es_format_Clean( &p_dec->fmt_out );
136
    free( p_dec->p_sys );
137 138
}

139 140 141 142 143 144 145 146 147 148
static void Flush( decoder_t *p_dec )
{
    block_t *p_ret = p_dec->p_sys->p_block;
    if ( p_ret )
    {
        block_Release( p_ret );
        p_dec->p_sys->p_block = NULL;
    }
}

149
/*****************************************************************************
150
 * Packetize: packetize an unit (here copy a complete block )
151
 *****************************************************************************/
152
static block_t *Packetize ( decoder_t *p_dec, block_t **pp_block )
153
{
154 155
    block_t *p_block;
    block_t *p_ret = p_dec->p_sys->p_block;
156

157
    if( pp_block == NULL || *pp_block == NULL )
158
        return NULL;
159
    if( (*pp_block)->i_flags&(BLOCK_FLAG_CORRUPTED) )
160
    {
161
        block_Release( *pp_block );
162
        return NULL;
163
    }
164

165 166
    p_block = *pp_block;
    *pp_block = NULL;
167

168
    if( p_block->i_dts <= VLC_TS_INVALID )
169 170 171 172
    {
        p_block->i_dts = p_block->i_pts;
    }

173
    if( p_block->i_dts <= VLC_TS_INVALID )
174
    {
175
        msg_Dbg( p_dec, "need valid dts" );
176 177
        block_Release( p_block );
        return NULL;
178
    }
179

180
    if( p_ret != NULL && p_block->i_pts > p_ret->i_pts )
181
    {
182 183
        if (p_dec->fmt_in.i_codec != VLC_CODEC_OPUS)
            p_ret->i_length = p_block->i_pts - p_ret->i_pts;
184
    }
185
    p_dec->p_sys->p_block = p_block;
186

187 188
    if( p_ret && p_dec->p_sys->pf_parse )
        p_dec->p_sys->pf_parse( p_dec, p_ret );
189
    return p_ret;
190
}
191 192 193 194 195 196 197 198 199

/*****************************************************************************
 * PacketizeSub: packetize an unit (here copy a complete block )
 *****************************************************************************/
static block_t *PacketizeSub( decoder_t *p_dec, block_t **pp_block )
{
    block_t *p_block;

    if( pp_block == NULL || *pp_block == NULL )
200
        return NULL;
201
    if( (*pp_block)->i_flags&(BLOCK_FLAG_CORRUPTED) )
202
    {
203
        block_Release( *pp_block );
204 205
        return NULL;
    }
206

207 208 209
    p_block = *pp_block;
    *pp_block = NULL;

210
    if( p_block->i_dts <= VLC_TS_INVALID )
211 212 213 214
    {
        p_block->i_dts = p_block->i_pts;
    }

215
    if( p_block->i_dts <= VLC_TS_INVALID )
216
    {
217
        msg_Dbg( p_dec, "need valid dts" );
218 219 220 221 222 223
        block_Release( p_block );
        return NULL;
    }

    return p_block;
}
224

225
/* Parse WMV3 packet and extract frame type information */
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
static void ParseWMV3( decoder_t *p_dec, block_t *p_block )
{
    bs_t s;

    /* Parse Sequence header */
    bs_init( &s, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
    if( bs_read( &s, 2 ) == 3 )
        return;
    bs_skip( &s, 22 );
    const bool b_range_reduction = bs_read( &s, 1 );
    const bool b_has_frames = bs_read( &s, 3 ) > 0;
    bs_skip( &s, 2 );
    const bool b_frame_interpolation = bs_read( &s, 1 );
    if( bs_eof( &s ) )
        return;

    /* Parse frame type */
    bs_init( &s, p_block->p_buffer, p_block->i_buffer );
    bs_skip( &s, b_frame_interpolation +
                 2 +
                 b_range_reduction );

    p_block->i_flags &= ~BLOCK_FLAG_TYPE_MASK;
    if( bs_read( &s, 1 ) )
        p_block->i_flags |= BLOCK_FLAG_TYPE_P;
    else if( !b_has_frames || bs_read( &s, 1 ) )
        p_block->i_flags |= BLOCK_FLAG_TYPE_I;
    else
        p_block->i_flags |= BLOCK_FLAG_TYPE_B;
}