copy.c 7.3 KB
Newer Older
1 2 3
/*****************************************************************************
 * copy.c
 *****************************************************************************
4
 * Copyright (C) 2001, 2002, 2006 the VideoLAN team
5
 * $Id$
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Eric Petit <titer@videolan.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (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
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
Antoine Cellerier's avatar
Antoine Cellerier committed
22
 * 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>
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

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

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

78 79 80
    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 )
81
    {
82 83
        msg_Err( p_dec, "invalid ES type" );
        return VLC_EGENERIC;
84 85
    }

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

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

94 95
    /* Fix the value of the fourcc for audio */
    if( p_dec->fmt_in.i_cat == AUDIO_ES )
96
    {
97 98 99 100 101 102 103
        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;
        }
104
    }
105

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

118 119
    return VLC_SUCCESS;
}
120

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

128
    if( p_dec->p_sys->p_block )
129
    {
130
        block_ChainRelease( p_dec->p_sys->p_block );
131
    }
132

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

/*****************************************************************************
138
 * Packetize: packetize an unit (here copy a complete block )
139
 *****************************************************************************/
140
static block_t *Packetize ( decoder_t *p_dec, block_t **pp_block )
141
{
142 143
    block_t *p_block;
    block_t *p_ret = p_dec->p_sys->p_block;
144

145
    if( pp_block == NULL || *pp_block == NULL )
146 147
        return NULL;
    if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
148
    {
149
        block_Release( *pp_block );
150
        return NULL;
151
    }
152

153 154
    p_block = *pp_block;
    *pp_block = NULL;
155

156
    if( p_block->i_dts <= VLC_TS_INVALID )
157 158 159 160
    {
        p_block->i_dts = p_block->i_pts;
    }

161
    if( p_block->i_dts <= VLC_TS_INVALID )
162
    {
163
        msg_Dbg( p_dec, "need valid dts" );
164 165
        block_Release( p_block );
        return NULL;
166
    }
167

168
    if( p_ret != NULL && p_block->i_pts > p_ret->i_pts )
169
    {
170
        p_ret->i_length = p_block->i_pts - p_ret->i_pts;
171
    }
172
    p_dec->p_sys->p_block = p_block;
173

174 175
    if( p_ret && p_dec->p_sys->pf_parse )
        p_dec->p_sys->pf_parse( p_dec, p_ret );
176
    return p_ret;
177
}
178 179 180 181 182 183 184 185 186

/*****************************************************************************
 * 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 )
187 188
        return NULL;
    if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
189
    {
190
        block_Release( *pp_block );
191 192
        return NULL;
    }
193

194 195 196
    p_block = *pp_block;
    *pp_block = NULL;

197
    if( p_block->i_dts <= VLC_TS_INVALID )
198 199 200 201
    {
        p_block->i_dts = p_block->i_pts;
    }

202
    if( p_block->i_dts <= VLC_TS_INVALID )
203
    {
204
        msg_Dbg( p_dec, "need valid dts" );
205 206 207 208 209 210
        block_Release( p_block );
        return NULL;
    }

    return p_block;
}
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243

/* Parse WMV3 packet and extract frame type informations */
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;
}