1 /*****************************************************************************
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 the VideoLAN team
5 * $Id: copy.c 18231 2006-12-03 17:02:02Z courmisch $
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Gildas Bazin <gbazin@videolan.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
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 General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
34 #include <vlc_codec.h>
35 #include <vlc_block.h>
38 #include "vlc_block_helper.h"
40 /*****************************************************************************
42 *****************************************************************************/
43 static int Open ( vlc_object_t * );
44 static void Close( vlc_object_t * );
47 set_category( CAT_SOUT );
48 set_subcategory( SUBCAT_SOUT_PACKETIZER );
49 set_description( _("VC-1 packetizer") );
50 set_capability( "packetizer", 50 );
51 set_callbacks( Open, Close );
54 /*****************************************************************************
56 *****************************************************************************/
62 block_bytestream_t bytestream;
65 uint8_t p_startcode[3];
67 /* Current sequence header */
68 vlc_bool_t b_sequence_header;
72 vlc_bool_t b_advanced_profile;
73 vlc_bool_t b_interlaced;
74 vlc_bool_t b_frame_interpolation;
75 vlc_bool_t b_range_reduction;
76 vlc_bool_t b_has_bframe;
78 vlc_bool_t b_entry_point;
87 /* Current frame being built */
92 mtime_t i_interpolated_dts;
103 IDU_TYPE_SEQUENCE_HEADER = 0x0f,
104 IDU_TYPE_ENTRY_POINT = 0x0e,
105 IDU_TYPE_FRAME = 0x0D,
106 IDU_TYPE_FIELD = 0x0C,
107 IDU_TYPE_SLICE = 0x0B,
108 IDU_TYPE_END_OF_SEQUENCE = 0x0B,
110 IDU_TYPE_SEQUENCE_LEVEL_USER_DATA = 0x1F,
111 IDU_TYPE_ENTRY_POINT_USER_DATA = 0x1E,
112 IDU_TYPE_FRAME_USER_DATA = 0x1D,
113 IDU_TYPE_FIELD_USER_DATA = 0x1C,
114 IDU_TYPE_SLICE_USER_DATA = 0x1B,
117 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block );
119 /*****************************************************************************
120 * Open: probe the packetizer and return score
121 *****************************************************************************
122 * Tries to launch a decoder and return score so that the interface is able
124 *****************************************************************************/
125 static int Open( vlc_object_t *p_this )
127 decoder_t *p_dec = (decoder_t*)p_this;
128 decoder_sys_t *p_sys;
130 if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'W', 'V', 'C', '1' ) )
133 p_dec->pf_packetize = Packetize;
135 /* Create the output format */
136 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
137 p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
139 p_sys->i_state = STATE_NOSYNC;
140 p_sys->bytestream = block_BytestreamInit();
141 p_sys->p_startcode[0] = 0x00;
142 p_sys->p_startcode[1] = 0x00;
143 p_sys->p_startcode[2] = 0x01;
146 p_sys->b_sequence_header = VLC_FALSE;
147 p_sys->sh.p_sh = NULL;
148 p_sys->b_entry_point = VLC_FALSE;
149 p_sys->ep.p_ep = NULL;
151 p_sys->b_frame = VLC_FALSE;
152 p_sys->p_frame = NULL;
153 p_sys->pp_last = &p_sys->p_frame;
155 p_sys->i_interpolated_dts = -1;
158 if( p_dec->fmt_in.i_extra > 0 )
160 block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
163 memcpy( p_init->p_buffer, p_dec->fmt_in.p_extra,
164 p_dec->fmt_in.i_extra );
166 while( ( p_pic = Packetize( p_dec, &p_init ) ) )
167 block_Release( p_pic ); /* Should not happen (only sequence header) */
173 /*****************************************************************************
175 *****************************************************************************/
176 static void Close( vlc_object_t *p_this )
178 decoder_t *p_dec = (decoder_t*)p_this;
179 decoder_sys_t *p_sys = p_dec->p_sys;
181 block_BytestreamRelease( &p_sys->bytestream );
183 block_Release( p_sys->p_frame );
187 /*****************************************************************************
188 * Packetize: packetize an access unit
189 *****************************************************************************/
190 static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag );
192 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
194 decoder_sys_t *p_sys = p_dec->p_sys;
197 if( pp_block == NULL || *pp_block == NULL )
200 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
202 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
204 p_sys->i_state = STATE_NOSYNC;
205 block_BytestreamFlush( &p_sys->bytestream );
208 block_ChainRelease( p_sys->p_frame );
209 p_sys->p_frame = NULL;
210 p_sys->pp_last = &p_sys->p_frame;
211 p_sys->b_frame = VLC_FALSE;
213 // p_sys->i_interpolated_dts = 0;
214 block_Release( *pp_block );
218 block_BytestreamPush( &p_sys->bytestream, *pp_block );
222 switch( p_sys->i_state )
226 if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) == VLC_SUCCESS )
227 p_sys->i_state = STATE_NEXT_SYNC;
229 if( p_sys->i_offset )
231 block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
233 block_BytestreamFlush( &p_sys->bytestream );
236 if( p_sys->i_state != STATE_NEXT_SYNC )
237 return NULL; /* Need more data */
239 p_sys->i_offset = 4; /* To find next startcode */
241 case STATE_NEXT_SYNC:
242 /* TODO: If p_block == NULL, flush the buffer without checking the
245 /* Find the next startcode */
246 if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) != VLC_SUCCESS )
247 return NULL; /* Need more data */
249 /* Get the new fragment and set the pts/dts */
250 p_pic = block_New( p_dec, p_sys->i_offset );
251 block_BytestreamFlush( &p_sys->bytestream );
252 p_pic->i_pts = p_sys->bytestream.p_block->i_pts;
253 p_pic->i_dts = p_sys->bytestream.p_block->i_dts;
254 p_pic->i_rate = p_sys->bytestream.p_block->i_rate;
256 block_GetBytes( &p_sys->bytestream, p_pic->p_buffer, p_pic->i_buffer );
260 /* Parse and return complete frame */
261 p_pic = ParseIDU( p_dec, p_pic );
263 /* Don't reuse the same timestamps several times */
264 if( p_sys->p_frame &&
265 p_sys->p_frame->i_dts == p_sys->bytestream.p_block->i_dts &&
266 p_sys->p_frame->i_pts == p_sys->bytestream.p_block->i_pts )
268 p_sys->bytestream.p_block->i_pts = -1;
269 p_sys->bytestream.p_block->i_dts = -1;
275 p_sys->i_state = STATE_NOSYNC;
279 if( p_sys->i_interpolated_dts < 0 )
281 msg_Dbg( p_dec, "need a starting pts/dts" );
282 p_sys->i_state = STATE_NOSYNC;
283 block_Release( p_pic );
287 /* So p_block doesn't get re-added several times */
288 *pp_block = block_BytestreamPop( &p_sys->bytestream );
290 p_sys->i_state = STATE_NOSYNC;
297 /* DecodeRIDU: decode the startcode emulation prevention (same than h264) */
298 static void DecodeRIDU( uint8_t *p_ret, int *pi_ret, uint8_t *src, int i_src )
300 uint8_t *end = &src[i_src];
301 uint8_t *dst_end = &p_ret[*pi_ret];
302 uint8_t *dst = p_ret;
304 while( src < end && dst < dst_end )
306 if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
318 *pi_ret = dst - p_ret;
320 /* BuildExtraData: gather sequence header and entry point */
321 static void BuildExtraData( decoder_t *p_dec )
323 decoder_sys_t *p_sys = p_dec->p_sys;
324 es_format_t *p_es = &p_dec->fmt_out;
326 if( !p_sys->b_sequence_header || !p_sys->b_entry_point )
329 i_extra = p_sys->sh.p_sh->i_buffer + p_sys->ep.p_ep->i_buffer;
330 if( p_es->i_extra != i_extra )
332 p_es->i_extra = i_extra;
333 p_es->p_extra = realloc( p_dec->fmt_out.p_extra, p_es->i_extra );
335 memcpy( p_es->p_extra,
336 p_sys->sh.p_sh->p_buffer, p_sys->sh.p_sh->i_buffer );
337 memcpy( (uint8_t*)p_es->p_extra + p_sys->sh.p_sh->i_buffer,
338 p_sys->ep.p_ep->p_buffer, p_sys->ep.p_ep->i_buffer );
340 /* ParseIDU: parse an Independant Decoding Unit */
341 static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag )
343 decoder_sys_t *p_sys = p_dec->p_sys;
345 const idu_type_t idu = p_frag->p_buffer[3];
347 if( !p_sys->b_sequence_header && idu != IDU_TYPE_SEQUENCE_HEADER )
349 msg_Warn( p_dec, "waiting for sequence header" );
350 block_Release( p_frag );
353 if( p_sys->b_sequence_header && !p_sys->b_entry_point && idu != IDU_TYPE_ENTRY_POINT )
355 msg_Warn( p_dec, "waiting for entry point" );
356 block_Release( p_frag );
359 /* TODO we do not gather ENTRY_POINT and SEQUENCE_DATA user data
360 * But It should not be a problem for decoder */
362 /* Do we have completed a frame */
364 if( p_sys->b_frame &&
365 idu != IDU_TYPE_FRAME_USER_DATA &&
366 idu != IDU_TYPE_FIELD && idu != IDU_TYPE_FIELD_USER_DATA &&
367 idu != IDU_TYPE_SLICE && idu != IDU_TYPE_SLICE_USER_DATA &&
368 idu != IDU_TYPE_END_OF_SEQUENCE )
371 p_pic = block_ChainGather( p_sys->p_frame );
373 /* We can interpolate dts/pts only if we have a frame rate */
374 if( p_dec->fmt_out.video.i_frame_rate != 0 && p_dec->fmt_out.video.i_frame_rate_base != 0 )
376 //msg_Dbg( p_dec, "-------------- XXX0 dts="I64Fd" pts="I64Fd" interpolated="I64Fd, p_pic->i_dts, p_pic->i_pts, p_sys->i_interpolated_dts );
377 if( p_pic->i_dts <= 0 )
378 p_pic->i_dts = p_sys->i_interpolated_dts;
380 p_sys->i_interpolated_dts += I64C(1000000) * p_dec->fmt_out.video.i_frame_rate_base / p_dec->fmt_out.video.i_frame_rate;
381 if( p_pic->i_pts <= 0 )
383 if( !p_sys->sh.b_has_bframe || (p_pic->i_flags & BLOCK_FLAG_TYPE_B ) )
384 p_pic->i_pts = p_pic->i_dts;
385 /* TODO compute pts for other case */
388 p_sys->i_interpolated_dts = p_pic->i_dts;
390 //msg_Dbg( p_dec, "-------------- dts="I64Fd" pts="I64Fd, p_pic->i_dts, p_pic->i_pts );
393 p_sys->p_frame = NULL;
394 p_sys->pp_last = &p_sys->p_frame;
400 block_t *p_frame = p_sys->p_frame;
401 if( p_frame->i_dts < 0 )
402 p_frame->i_dts = p_frag->i_dts;
403 if( p_frame->i_pts < 0 )
404 p_frame->i_pts = p_frag->i_pts;
406 block_ChainLastAppend( &p_sys->pp_last, p_frag );
409 if( idu == IDU_TYPE_SEQUENCE_HEADER )
411 es_format_t *p_es = &p_dec->fmt_out;
415 int i_ridu = sizeof(ridu);
419 block_Release( p_sys->sh.p_sh );
420 p_sys->sh.p_sh = block_Duplicate( p_frag );
422 /* Extract the raw IDU */
423 DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
425 /* Auto detect VC-1_SPMP_PESpacket_PayloadFormatHeader (SMPTE RP 227) for simple/main profile
426 * TODO find a test case and valid it */
427 if( i_ridu > 4 && (ridu[0]&0x80) == 0 ) /* for advanced profile, the first bit is 1 */
429 video_format_t *p_v = &p_dec->fmt_in.video;
430 const size_t i_potential_width = GetWBE( &ridu[0] );
431 const size_t i_potential_height = GetWBE( &ridu[2] );
433 if( i_potential_width >= 2 && i_potential_width <= 8192 &&
434 i_potential_height >= 2 && i_potential_height <= 8192 )
436 if( ( p_v->i_width <= 0 && p_v->i_height <= 0 ) ||
437 ( p_v->i_width == i_potential_width && p_v->i_height == i_potential_height ) )
439 static const uint8_t startcode[4] = { 0x00, 0x00, 0x01, IDU_TYPE_SEQUENCE_HEADER };
440 p_es->video.i_width = i_potential_width;
441 p_es->video.i_height = i_potential_height;
444 p_frag->p_buffer += 4;
445 p_frag->i_buffer -= 4;
446 memcpy( p_frag->p_buffer, startcode, sizeof(startcode) );
452 bs_init( &s, ridu, i_ridu );
453 i_profile = bs_read( &s, 2 );
456 const int i_level = bs_read( &s, 3 );
458 /* Advanced profile */
459 p_sys->sh.b_advanced_profile = VLC_TRUE;
460 p_sys->sh.b_range_reduction = VLC_FALSE;
461 p_sys->sh.b_has_bframe = VLC_TRUE;
463 bs_skip( &s, 2+3+5+1 ); // chroma format + frame rate Q + bit rate Q + postprocflag
465 p_es->video.i_width = 2*bs_read( &s, 12 )+2;
466 p_es->video.i_height = 2*bs_read( &s, 12 )+2;
468 if( !p_sys->b_sequence_header )
469 msg_Dbg( p_dec, "found sequence header for advanced profile level L%d resolution %dx%d",
470 i_level, p_es->video.i_width, p_es->video.i_height);
472 bs_skip( &s, 1 );// pulldown
473 p_sys->sh.b_interlaced = bs_read( &s, 1 );
474 bs_skip( &s, 1 );// frame counter
475 p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
476 bs_skip( &s, 1 ); // Reserved
477 bs_skip( &s, 1 ); // Psf
479 if( bs_read( &s, 1 ) ) /* Display extension */
481 const int i_display_width = bs_read( &s, 14 )+1;
482 const int i_display_height = bs_read( &s, 14 )+1;
484 p_es->video.i_aspect = VOUT_ASPECT_FACTOR * i_display_width / i_display_height;
486 if( !p_sys->b_sequence_header )
487 msg_Dbg( p_dec, "display size %dx%d", i_display_width, i_display_height );
489 if( bs_read( &s, 1 ) ) /* Pixel aspect ratio (PAR/SAR) */
491 static const int p_ar[16][2] = {
492 { 0, 0}, { 1, 1}, {12,11}, {10,11}, {16,11}, {40,33},
493 {24,11}, {20,11}, {32,11}, {80,33}, {18,11}, {15,11},
494 {64,33}, {160,99},{ 0, 0}, { 0, 0}
496 int i_ar = bs_read( &s, 4 );
497 unsigned i_ar_w, i_ar_h;
501 i_ar_w = bs_read( &s, 8 );
502 i_ar_h = bs_read( &s, 8 );
506 i_ar_w = p_ar[i_ar][0];
507 i_ar_h = p_ar[i_ar][1];
509 vlc_ureduce( &i_ar_w, &i_ar_h, i_ar_w, i_ar_h, 0 );
510 if( !p_sys->b_sequence_header )
511 msg_Dbg( p_dec, "aspect ratio %d:%d", i_ar_w, i_ar_h );
514 if( bs_read( &s, 1 ) ) /* Frame rate */
518 if( bs_read( &s, 1 ) )
520 i_fps_num = bs_read( &s, 16 )+1;
525 const int i_nr = bs_read( &s, 8 );
526 const int i_dn = bs_read( &s, 4 );
530 case 1: i_fps_num = 24000; break;
531 case 2: i_fps_num = 25000; break;
532 case 3: i_fps_num = 30000; break;
533 case 4: i_fps_num = 50000; break;
534 case 5: i_fps_num = 60000; break;
535 case 6: i_fps_num = 48000; break;
536 case 7: i_fps_num = 72000; break;
540 case 1: i_fps_den = 1000; break;
541 case 2: i_fps_den = 1001; break;
544 if( i_fps_num != 0 && i_fps_den != 0 )
545 vlc_ureduce( &p_es->video.i_frame_rate, &p_es->video.i_frame_rate_base, i_fps_num, i_fps_den, 0 );
547 if( !p_sys->b_sequence_header )
548 msg_Dbg( p_dec, "frame rate %d/%d", p_es->video.i_frame_rate, p_es->video.i_frame_rate_base );
553 /* Simple and main profile */
554 p_sys->sh.b_advanced_profile = VLC_FALSE;
555 p_sys->sh.b_interlaced = VLC_FALSE;
557 if( !p_sys->b_sequence_header )
558 msg_Dbg( p_dec, "found sequence header for %s profile", i_profile == 0 ? "simple" : "main" );
560 bs_skip( &s, 2+3+5+1+1+ // reserved + frame rate Q + bit rate Q + loop filter + reserved
561 1+1+1+1+2+ // multiresolution + reserved + fast uv mc + extended mv + dquant
562 1+1+1+1 ); // variable size transform + reserved + overlap + sync marker
563 p_sys->sh.b_range_reduction = bs_read( &s, 1 );
564 if( bs_read( &s, 3 ) > 0 )
565 p_sys->sh.b_has_bframe = VLC_TRUE;
567 p_sys->sh.b_has_bframe = VLC_FALSE;
568 bs_skip( &s, 2 ); // quantizer
570 p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
572 p_sys->b_sequence_header = VLC_TRUE;
573 BuildExtraData( p_dec );
575 else if( idu == IDU_TYPE_ENTRY_POINT )
578 block_Release( p_sys->ep.p_ep );
579 p_sys->ep.p_ep = block_Duplicate( p_frag );
581 p_sys->b_entry_point = VLC_TRUE;
582 BuildExtraData( p_dec );
584 else if( idu == IDU_TYPE_FRAME )
588 int i_ridu = sizeof(ridu);
590 /* Extract the raw IDU */
591 DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
593 /* Parse it + interpolate pts/dts if possible */
594 bs_init( &s, ridu, i_ridu );
596 if( p_sys->sh.b_advanced_profile )
600 if( p_sys->sh.b_interlaced )
602 if( bs_read( &s, 1 ) )
604 if( bs_read( &s, 1 ) )
605 i_fcm = 1; /* interlaced field */
607 i_fcm = 2; /* interlaced frame */
611 if( i_fcm == 1 ) /*interlaced field */
613 /* XXX for mixed I/P we should check reference usage before marking them I (too much work) */
614 switch( bs_read( &s, 3 ) )
619 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
620 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
621 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
624 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
630 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
636 if( !bs_read( &s, 1 ) )
637 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
638 else if( !bs_read( &s, 1 ) )
639 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
640 else if( !bs_read( &s, 1 ) )
641 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
642 else if( !bs_read( &s, 1 ) )
643 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B; /* Bi */
645 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P; /* P Skip */
650 if( p_sys->sh.b_frame_interpolation )
651 bs_skip( &s, 1 ); // interpolate
652 bs_skip( &s, 2 ); // frame count
653 if( p_sys->sh.b_range_reduction )
654 bs_skip( &s, 1 ); // range reduction
656 if( bs_read( &s, 1 ) )
657 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
658 else if( !p_sys->sh.b_has_bframe || bs_read( &s, 1 ) )
659 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
661 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
663 p_sys->b_frame = VLC_TRUE;