copy: Don't modify fmt_out until success is ensured
[vlc.git] / modules / packetizer / copy.c
1 /*****************************************************************************
2  * copy.c
3  *****************************************************************************
4  * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Eric Petit <titer@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_block.h>
37 #include <vlc_bits.h>
38
39 /*****************************************************************************
40  * Module descriptor
41  *****************************************************************************/
42 static int  Open ( vlc_object_t * );
43 static void Close( vlc_object_t * );
44
45 vlc_module_begin ()
46     set_category( CAT_SOUT )
47     set_subcategory( SUBCAT_SOUT_PACKETIZER )
48     set_description( N_("Copy packetizer") )
49     set_capability( "packetizer", 1 )
50     set_callbacks( Open, Close )
51 vlc_module_end ()
52
53 /*****************************************************************************
54  * Local prototypes
55  *****************************************************************************/
56 struct decoder_sys_t
57 {
58     block_t *p_block;
59     void (*pf_parse)( decoder_t *, block_t * );
60 };
61
62 static block_t *Packetize   ( decoder_t *, block_t ** );
63 static block_t *PacketizeSub( decoder_t *, block_t ** );
64 static void Flush( decoder_t * );
65
66 static void ParseWMV3( decoder_t *, block_t * );
67
68 /*****************************************************************************
69  * Open: probe the packetizer and return score
70  *****************************************************************************
71  * Tries to launch a decoder and return score so that the interface is able
72  * to choose.
73  *****************************************************************************/
74 static int Open( vlc_object_t *p_this )
75 {
76     decoder_t     *p_dec = (decoder_t*)p_this;
77     decoder_sys_t *p_sys;
78
79     if( p_dec->fmt_in.i_cat != AUDIO_ES &&
80         p_dec->fmt_in.i_cat != VIDEO_ES &&
81         p_dec->fmt_in.i_cat != SPU_ES )
82     {
83         msg_Err( p_dec, "invalid ES type" );
84         return VLC_EGENERIC;
85     }
86
87     if( p_dec->fmt_in.i_cat == SPU_ES )
88         p_dec->pf_packetize = PacketizeSub;
89     else
90         p_dec->pf_packetize = Packetize;
91     p_dec->pf_flush = Flush;
92
93     p_dec->p_sys = p_sys = malloc( sizeof(*p_sys) );
94     if (unlikely(p_sys == NULL))
95         return VLC_ENOMEM;
96
97     p_sys->p_block    = NULL;
98     switch( p_dec->fmt_in.i_codec )
99     {
100     case VLC_CODEC_WMV3:
101         p_sys->pf_parse = ParseWMV3;
102         break;
103     default:
104         p_sys->pf_parse = NULL;
105         break;
106     }
107
108     vlc_fourcc_t fcc = p_dec->fmt_out.i_codec;
109     /* Fix the value of the fourcc for audio */
110     if( p_dec->fmt_in.i_cat == AUDIO_ES )
111     {
112         fcc = vlc_fourcc_GetCodecAudio( p_dec->fmt_in.i_codec,
113                                                      p_dec->fmt_in.audio.i_bitspersample );
114         if( !fcc )
115         {
116             msg_Err( p_dec, "unknown raw audio sample size" );
117             free( p_sys );
118             return VLC_EGENERIC;
119         }
120     }
121
122     /* Create the output format */
123     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
124     p_dec->fmt_out.i_codec = fcc;
125
126     return VLC_SUCCESS;
127 }
128
129 /*****************************************************************************
130  * Close:
131  *****************************************************************************/
132 static void Close( vlc_object_t *p_this )
133 {
134     decoder_t     *p_dec = (decoder_t*)p_this;
135
136     if( p_dec->p_sys->p_block )
137     {
138         block_ChainRelease( p_dec->p_sys->p_block );
139     }
140
141     free( p_dec->p_sys );
142 }
143
144 static void Flush( decoder_t *p_dec )
145 {
146     block_t *p_ret = p_dec->p_sys->p_block;
147     if ( p_ret )
148     {
149         block_Release( p_ret );
150         p_dec->p_sys->p_block = NULL;
151     }
152 }
153
154 /*****************************************************************************
155  * Packetize: packetize an unit (here copy a complete block )
156  *****************************************************************************/
157 static block_t *Packetize ( decoder_t *p_dec, block_t **pp_block )
158 {
159     block_t *p_block;
160     block_t *p_ret = p_dec->p_sys->p_block;
161
162     if( pp_block == NULL || *pp_block == NULL )
163         return NULL;
164     if( (*pp_block)->i_flags&(BLOCK_FLAG_CORRUPTED) )
165     {
166         block_Release( *pp_block );
167         return NULL;
168     }
169
170     p_block = *pp_block;
171     *pp_block = NULL;
172
173     if( p_block->i_dts <= VLC_TS_INVALID )
174     {
175         p_block->i_dts = p_block->i_pts;
176     }
177
178     if( p_block->i_dts <= VLC_TS_INVALID )
179     {
180         msg_Dbg( p_dec, "need valid dts" );
181         block_Release( p_block );
182         return NULL;
183     }
184
185     if( p_ret != NULL && p_block->i_pts > p_ret->i_pts )
186     {
187         if (p_dec->fmt_in.i_codec != VLC_CODEC_OPUS)
188             p_ret->i_length = p_block->i_pts - p_ret->i_pts;
189     }
190     p_dec->p_sys->p_block = p_block;
191
192     if( p_ret && p_dec->p_sys->pf_parse )
193         p_dec->p_sys->pf_parse( p_dec, p_ret );
194     return p_ret;
195 }
196
197 /*****************************************************************************
198  * PacketizeSub: packetize an unit (here copy a complete block )
199  *****************************************************************************/
200 static block_t *PacketizeSub( decoder_t *p_dec, block_t **pp_block )
201 {
202     block_t *p_block;
203
204     if( pp_block == NULL || *pp_block == NULL )
205         return NULL;
206     if( (*pp_block)->i_flags&(BLOCK_FLAG_CORRUPTED) )
207     {
208         block_Release( *pp_block );
209         return NULL;
210     }
211
212     p_block = *pp_block;
213     *pp_block = NULL;
214
215     if( p_block->i_dts <= VLC_TS_INVALID )
216     {
217         p_block->i_dts = p_block->i_pts;
218     }
219
220     if( p_block->i_dts <= VLC_TS_INVALID )
221     {
222         msg_Dbg( p_dec, "need valid dts" );
223         block_Release( p_block );
224         return NULL;
225     }
226
227     return p_block;
228 }
229
230 /* Parse WMV3 packet and extract frame type information */
231 static void ParseWMV3( decoder_t *p_dec, block_t *p_block )
232 {
233     bs_t s;
234
235     /* Parse Sequence header */
236     bs_init( &s, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
237     if( bs_read( &s, 2 ) == 3 )
238         return;
239     bs_skip( &s, 22 );
240     const bool b_range_reduction = bs_read( &s, 1 );
241     const bool b_has_frames = bs_read( &s, 3 ) > 0;
242     bs_skip( &s, 2 );
243     const bool b_frame_interpolation = bs_read( &s, 1 );
244     if( bs_eof( &s ) )
245         return;
246
247     /* Parse frame type */
248     bs_init( &s, p_block->p_buffer, p_block->i_buffer );
249     bs_skip( &s, b_frame_interpolation +
250                  2 +
251                  b_range_reduction );
252
253     p_block->i_flags &= ~BLOCK_FLAG_TYPE_MASK;
254     if( bs_read( &s, 1 ) )
255         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
256     else if( !b_has_frames || bs_read( &s, 1 ) )
257         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
258     else
259         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
260 }
261