1 /*****************************************************************************
2 * rawvideo.c: Pseudo video decoder/packetizer for raw video data
3 *****************************************************************************
4 * Copyright (C) 2001, 2002 VLC authors and VideoLAN
5 * $Id: e98061dc60dc788c30e9e375c9c348b3cd9030dc $
6 *
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25 * Preamble
26 *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_codec.h>
34
35 /*****************************************************************************
36 * decoder_sys_t : raw video decoder descriptor
37 *****************************************************************************/
38 struct decoder_sys_t
39 {
40 /*
41 * Input properties
42 */
43 size_t size;
44 unsigned pitches[PICTURE_PLANE_MAX];
45 unsigned lines[PICTURE_PLANE_MAX];
46
47 /*
48 * Common properties
49 */
50 date_t pts;
51 };
52
53 /****************************************************************************
54 * Local prototypes
55 ****************************************************************************/
56 static int OpenDecoder ( vlc_object_t * );
57 static int OpenPacketizer( vlc_object_t * );
58 static void CloseCommon ( vlc_object_t * );
59
60 /*****************************************************************************
61 * Module descriptor
62 *****************************************************************************/
63 vlc_module_begin ()
64 set_description( N_("Pseudo raw video decoder") )
65 set_capability( "video decoder", 50 )
set_category(CAT_INPUT)66 set_category( CAT_INPUT )
67 set_subcategory( SUBCAT_INPUT_VCODEC )
68 set_callbacks( OpenDecoder, CloseCommon )
69
70 add_submodule ()
71 set_description( N_("Pseudo raw video packetizer") )
72 set_capability( "packetizer", 100 )
73 set_callbacks( OpenPacketizer, CloseCommon )
74 vlc_module_end ()
75
76 /**
77 * Common initialization for decoder and packetizer
78 */
79 static int OpenCommon( decoder_t *p_dec )
80 {
81 const vlc_chroma_description_t *dsc =
82 vlc_fourcc_GetChromaDescription( p_dec->fmt_in.i_codec );
83 if( dsc == NULL || dsc->plane_count == 0 )
84 return VLC_EGENERIC;
85
86 if( p_dec->fmt_in.video.i_width <= 0 || p_dec->fmt_in.video.i_height == 0 )
87 {
88 msg_Err( p_dec, "invalid display size %dx%d",
89 p_dec->fmt_in.video.i_width, p_dec->fmt_in.video.i_height );
90 return VLC_EGENERIC;
91 }
92
93 /* Allocate the memory needed to store the decoder's structure */
94 decoder_sys_t *p_sys = calloc(1, sizeof(*p_sys));
95 if( unlikely(p_sys == NULL) )
96 return VLC_ENOMEM;
97
98 if( !p_dec->fmt_in.video.i_visible_width )
99 p_dec->fmt_in.video.i_visible_width = p_dec->fmt_in.video.i_width;
100 if( !p_dec->fmt_in.video.i_visible_height )
101 p_dec->fmt_in.video.i_visible_height = p_dec->fmt_in.video.i_height;
102
103 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
104
105 if( p_dec->fmt_out.video.i_frame_rate == 0 ||
106 p_dec->fmt_out.video.i_frame_rate_base == 0)
107 {
108 msg_Warn( p_dec, "invalid frame rate %d/%d, using 25 fps instead",
109 p_dec->fmt_out.video.i_frame_rate,
110 p_dec->fmt_out.video.i_frame_rate_base);
111 date_Init( &p_sys->pts, 25, 1 );
112 }
113 else
114 date_Init( &p_sys->pts, p_dec->fmt_out.video.i_frame_rate,
115 p_dec->fmt_out.video.i_frame_rate_base );
116
117 for( unsigned i = 0; i < dsc->plane_count; i++ )
118 {
119 unsigned pitch = ((p_dec->fmt_in.video.i_width + (dsc->p[i].w.den - 1)) / dsc->p[i].w.den)
120 * dsc->p[i].w.num * dsc->pixel_size;
121 unsigned lines = ((p_dec->fmt_in.video.i_height + (dsc->p[i].h.den - 1)) / dsc->p[i].h.den)
122 * dsc->p[i].h.num;
123
124 p_sys->pitches[i] = pitch;
125 p_sys->lines[i] = lines;
126 p_sys->size += pitch * lines;
127 }
128
129 p_dec->p_sys = p_sys;
130 return VLC_SUCCESS;
131 }
132
133 /*****************************************************************************
134 * Flush:
135 *****************************************************************************/
Flush(decoder_t * p_dec)136 static void Flush( decoder_t *p_dec )
137 {
138 decoder_sys_t *p_sys = p_dec->p_sys;
139
140 date_Set( &p_sys->pts, VLC_TS_INVALID );
141 }
142
143 /****************************************************************************
144 * DecodeBlock: the whole thing
145 ****************************************************************************
146 * This function must be fed with complete frames.
147 ****************************************************************************/
DecodeBlock(decoder_t * p_dec,block_t * p_block)148 static block_t *DecodeBlock( decoder_t *p_dec, block_t *p_block )
149 {
150 decoder_sys_t *p_sys = p_dec->p_sys;
151
152 if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED|BLOCK_FLAG_DISCONTINUITY) )
153 {
154 date_Set( &p_sys->pts, p_block->i_dts );
155 if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
156 {
157 block_Release( p_block );
158 return NULL;
159 }
160 }
161
162 if( p_block->i_pts <= VLC_TS_INVALID && p_block->i_dts <= VLC_TS_INVALID &&
163 !date_Get( &p_sys->pts ) )
164 {
165 /* We've just started the stream, wait for the first PTS. */
166 block_Release( p_block );
167 return NULL;
168 }
169
170 /* Date management: If there is a pts avaliable, use that. */
171 if( p_block->i_pts > VLC_TS_INVALID )
172 {
173 date_Set( &p_sys->pts, p_block->i_pts );
174 }
175 else if( p_block->i_dts > VLC_TS_INVALID )
176 {
177 /* NB, davidf doesn't quite agree with this in general, it is ok
178 * for rawvideo since it is in order (ie pts=dts), however, it
179 * may not be ok for an out-of-order codec, so don't copy this
180 * without thinking */
181 date_Set( &p_sys->pts, p_block->i_dts );
182 }
183
184 if( p_block->i_buffer < p_sys->size )
185 {
186 msg_Warn( p_dec, "invalid frame size (%zu < %zu)",
187 p_block->i_buffer, p_sys->size );
188
189 block_Release( p_block );
190 return NULL;
191 }
192
193 return p_block;
194 }
195
196 /*****************************************************************************
197 * FillPicture:
198 *****************************************************************************/
FillPicture(decoder_t * p_dec,block_t * p_block,picture_t * p_pic)199 static void FillPicture( decoder_t *p_dec, block_t *p_block, picture_t *p_pic )
200 {
201 decoder_sys_t *p_sys = p_dec->p_sys;
202 const uint8_t *p_src = p_block->p_buffer;
203
204 for( int i = 0; i < p_pic->i_planes; i++ )
205 {
206 uint8_t *p_dst = p_pic->p[i].p_pixels;
207
208 for( int x = 0; x < p_pic->p[i].i_visible_lines; x++ )
209 {
210 memcpy( p_dst, p_src, p_pic->p[i].i_visible_pitch );
211 p_src += p_sys->pitches[i];
212 p_dst += p_pic->p[i].i_pitch;
213 }
214
215 p_src += p_sys->pitches[i]
216 * (p_sys->lines[i] - p_pic->p[i].i_visible_lines);
217 }
218 }
219
220 /*****************************************************************************
221 * DecodeFrame: decodes a video frame.
222 *****************************************************************************/
DecodeFrame(decoder_t * p_dec,block_t * p_block)223 static int DecodeFrame( decoder_t *p_dec, block_t *p_block )
224 {
225 if( p_block == NULL ) /* No Drain */
226 return VLCDEC_SUCCESS;
227
228 p_block = DecodeBlock( p_dec, p_block );
229 if( p_block == NULL )
230 return VLCDEC_SUCCESS;
231
232 decoder_sys_t *p_sys = p_dec->p_sys;
233
234 /* Get a new picture */
235 picture_t *p_pic = NULL;
236 if( !decoder_UpdateVideoFormat( p_dec ) )
237 p_pic = decoder_NewPicture( p_dec );
238 if( p_pic == NULL )
239 {
240 block_Release( p_block );
241 return VLCDEC_SUCCESS;
242 }
243
244 FillPicture( p_dec, p_block, p_pic );
245
246 /* Date management: 1 frame per packet */
247 p_pic->date = date_Get( &p_dec->p_sys->pts );
248 date_Increment( &p_sys->pts, 1 );
249
250 if( p_block->i_flags & BLOCK_FLAG_INTERLACED_MASK )
251 {
252 p_pic->b_progressive = false;
253 p_pic->i_nb_fields = (p_block->i_flags & BLOCK_FLAG_SINGLE_FIELD) ? 1 : 2;
254 if( p_block->i_flags & BLOCK_FLAG_TOP_FIELD_FIRST )
255 p_pic->b_top_field_first = true;
256 else
257 p_pic->b_top_field_first = false;
258 }
259 else
260 p_pic->b_progressive = true;
261
262 block_Release( p_block );
263 decoder_QueueVideo( p_dec, p_pic );
264 return VLCDEC_SUCCESS;
265 }
266
OpenDecoder(vlc_object_t * p_this)267 static int OpenDecoder( vlc_object_t *p_this )
268 {
269 decoder_t *p_dec = (decoder_t *)p_this;
270
271 int ret = OpenCommon( p_dec );
272 if( ret == VLC_SUCCESS )
273 {
274 p_dec->pf_decode = DecodeFrame;
275 p_dec->pf_flush = Flush;
276 }
277 return ret;
278 }
279
280 /*****************************************************************************
281 * SendFrame: send a video frame to the stream output.
282 *****************************************************************************/
SendFrame(decoder_t * p_dec,block_t ** pp_block)283 static block_t *SendFrame( decoder_t *p_dec, block_t **pp_block )
284 {
285 if( pp_block == NULL ) /* No Drain */
286 return NULL;
287
288 block_t *p_block = *pp_block;
289 if( p_block == NULL )
290 return NULL;
291 *pp_block = NULL;
292
293 p_block = DecodeBlock( p_dec, p_block );
294 if( p_block == NULL )
295 return NULL;
296
297 decoder_sys_t *p_sys = p_dec->p_sys;
298
299 /* Date management: 1 frame per packet */
300 p_block->i_dts = p_block->i_pts = date_Get( &p_sys->pts );
301 date_Increment( &p_sys->pts, 1 );
302 return p_block;
303 }
304
OpenPacketizer(vlc_object_t * p_this)305 static int OpenPacketizer( vlc_object_t *p_this )
306 {
307 decoder_t *p_dec = (decoder_t *)p_this;
308
309 int ret = OpenCommon( p_dec );
310 if( ret == VLC_SUCCESS )
311 p_dec->pf_packetize = SendFrame;
312 return ret;
313 }
314
315 /**
316 * Common deinitialization
317 */
CloseCommon(vlc_object_t * p_this)318 static void CloseCommon( vlc_object_t *p_this )
319 {
320 decoder_t *p_dec = (decoder_t*)p_this;
321 free( p_dec->p_sys );
322 }
323