static int OpenAudioDev( demux_t *p_demux, const char *psz_device ) { demux_sys_t *p_sys = p_demux->p_sys; if( OpenAudioDevAlsa( p_demux, psz_device ) != VLC_SUCCESS ) return VLC_EGENERIC; msg_Dbg( p_demux, "opened adev=`%s' %s %dHz", psz_device, p_sys->b_stereo ? "stereo" : "mono", p_sys->i_sample_rate ); es_format_t fmt; es_format_Init( &fmt, AUDIO_ES, VLC_FOURCC('a','r','a','w') ); fmt.audio.i_channels = p_sys->b_stereo ? 2 : 1; fmt.audio.i_rate = p_sys->i_sample_rate; fmt.audio.i_bitspersample = 16; fmt.audio.i_blockalign = fmt.audio.i_channels * fmt.audio.i_bitspersample / 8; fmt.i_bitrate = fmt.audio.i_channels * fmt.audio.i_rate * fmt.audio.i_bitspersample; msg_Dbg( p_demux, "new audio es %d channels %dHz", fmt.audio.i_channels, fmt.audio.i_rate ); p_sys->p_es = es_out_Add( p_demux->out, &fmt ); return VLC_SUCCESS; }
static int Open (vlc_object_t *obj) { demux_t *demux = (demux_t *)obj; demux_sys_t *sys = vlc_malloc(obj, sizeof (*sys)); if (unlikely(sys == NULL)) return VLC_ENOMEM; es_format_t fmt; es_format_Init (&fmt, SPU_ES, VLC_CODEC_ITU_T140); sys->es = es_out_Add (demux->out, &fmt); unsigned num, den; if (var_InheritURational (demux, &num, &den, "timecode-fps") || !num || !den) { msg_Err (demux, "invalid frame rate"); return VLC_EGENERIC; } date_Init (&sys->date, num, den); date_Set (&sys->date, VLC_TS_0); sys->next_time = VLC_TS_INVALID; demux->p_sys = sys; demux->pf_demux = Demux; demux->pf_control = Control; return VLC_SUCCESS; }
virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents events, IDeckLinkDisplayMode *mode, BMDDetectedVideoInputFormatFlags) { demux_sys_t *sys = demux_->p_sys; if( !(events & bmdVideoInputDisplayModeChanged )) return S_OK; const char *mode_name; if (mode->GetName(&mode_name) != S_OK) mode_name = "unknown"; msg_Dbg(demux_, "Video input format changed to %s", mode_name); if (!sys->autodetect) { msg_Err(demux_, "Video format detection disabled"); return S_OK; } es_out_Del(demux_->out, sys->video_es); es_format_t video_fmt = GetModeSettings(demux_, mode); sys->video_es = es_out_Add(demux_->out, &video_fmt); BMDPixelFormat fmt = sys->tenbits ? bmdFormat10BitYUV : bmdFormat8BitYUV; sys->input->PauseStreams(); sys->input->EnableVideoInput( mode->GetDisplayMode(), fmt, bmdVideoInputEnableFormatDetection ); sys->input->FlushStreams(); sys->input->StartStreams(); return S_OK; }
/***************************************************************************** * Open: check file and initializes structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; /* Identify cdg file by extension, as there is no simple way to * detect it */ if( !demux_IsPathExtension( p_demux, ".cdg" ) && !demux_IsForced( p_demux, "cdg" ) ) return VLC_EGENERIC; /* CDG file size has to be multiple of CDG_FRAME_SIZE (it works even * if size is unknown ie 0) */ // if( (stream_Size( p_demux->s ) % CDG_FRAME_SIZE) != 0 ) // { // msg_Err( p_demux, "Reject CDG file based on its size" ); // return VLC_EGENERIC; // } p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); /* */ es_format_Init( &p_sys->fmt, VIDEO_ES, VLC_CODEC_CDG ); p_sys->fmt.video.i_width = 300-2*6; p_sys->fmt.video.i_height = 216-2*12 ; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt ); /* There is CDG_FRAME_RATE frames per second */ date_Init( &p_sys->pts, CDG_FRAME_RATE, 1 ); date_Set( &p_sys->pts, 1 ); return VLC_SUCCESS; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; if( p_sys->i_state == DIRAC_DEMUX_DISCONT ) { p_sys->i_state++; p_block_in = block_Alloc( 128 ); if( p_block_in ) { p_block_in->i_flags = BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED; } } else { p_block_in = stream_Block( p_demux->s, DIRAC_PACKET_SIZE ); if( !p_block_in ) { return 0; } if ( p_sys->i_state == DIRAC_DEMUX_FIRST) { p_sys->i_state++; /* by default, timestamps are invalid. * Except when we need an anchor point */ p_block_in->i_dts = VLC_TS_0; } } while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, &p_block_in )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; p_block_out->p_next = NULL; if( p_sys->p_es == NULL ) p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); p_block_out->i_dts += p_sys->i_dtsoffset; p_sys->i_dts = p_block_out->i_dts; /* track low watermark for pts_offset -- can be used to show * when it is too large */ mtime_t i_delay = p_block_out->i_pts - p_block_out->i_dts; if( p_sys->i_pts_offset_lowtide > i_delay ) { p_sys->i_pts_offset_lowtide = i_delay; } es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts ); es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; } } return 1; }
/***************************************************************************** * Open: initializes demux structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; bool b_forced = false; const uint8_t *p_peek; es_format_t fmt; if( vlc_stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) { msg_Dbg( p_demux, "cannot peek" ); return VLC_EGENERIC; } if( p_demux->obj.force ) b_forced = true; if( p_peek[0] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x01 ) { if( !b_forced ) return VLC_EGENERIC; msg_Err( p_demux, "this doesn't look like an MPEG ES stream, continuing" ); } if( p_peek[3] > 0xb9 ) { if( !b_forced ) return VLC_EGENERIC; msg_Err( p_demux, "this seems to be a system stream (PS plug-in ?), but continuing" ); } p_demux->pf_demux = Demux; p_demux->pf_control= Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); p_sys->b_start = true; p_sys->p_es = NULL; /* Load the mpegvideo packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_MPGV ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "mpeg video" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } /* create the output */ p_sys->p_es = es_out_Add( p_demux->out, &fmt ); if( p_sys->p_es == NULL ) { Close( p_this ); return VLC_EGENERIC; } return VLC_SUCCESS; }
vlc_v4l2_vbi_t *OpenVBI (demux_t *demux, const char *psz_device) { vlc_v4l2_vbi_t *vbi = malloc (sizeof (*vbi)); if (unlikely(vbi == NULL)) return NULL; int rawfd = vlc_open (psz_device, O_RDWR); if (rawfd == -1) { msg_Err (demux, "cannot open device '%s': %m", psz_device); goto err; } //Can put more in here. See osd.c in zvbi package. unsigned int services = VBI_SLICED_CAPTION_525; char *errstr = NULL; vbi->cap = vbi_capture_v4l2k_new (psz_device, rawfd, /* buffers */ 5, &services, /* strict */ 1, &errstr, /* verbose */ 1); if (vbi->cap == NULL) { msg_Err (demux, "cannot capture VBI data: %s", errstr); free (errstr); goto err; } for (unsigned i = 0; i < VBI_NUM_CC_STREAMS; i++) { es_format_t fmt; es_format_Init (&fmt, SPU_ES, VLC_FOURCC('c', 'c', '1' + i, ' ')); if (asprintf (&fmt.psz_description, "Closed captions %d", i + 1) >= 0) { msg_Dbg (demux, "new spu es %4.4s", (char *)&fmt.i_codec); vbi->es[i] = es_out_Add (demux->out, &fmt); } } /* Do a single read and throw away the results so that ZVBI calls the STREAMON ioctl() */ GrabVBI(demux, vbi); return vbi; err: free (vbi); return NULL; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; if( ( p_block_in = stream_Block( p_demux->s, VC1_PACKET_SIZE ) ) == NULL ) return 0; /* */ p_block_in->i_dts = VLC_TS_0; p_block_in->i_pts = VLC_TS_0; while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, &p_block_in )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; p_block_out->p_next = NULL; if( p_sys->p_es == NULL ) { p_sys->p_packetizer->fmt_out.b_packetized = true; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); } es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_dts ); p_block_out->i_dts = VLC_TS_0 + p_sys->i_dts; p_block_out->i_pts = VLC_TS_0 + p_sys->i_dts; es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; if( p_sys->p_packetizer->fmt_out.video.i_frame_rate > 0 && p_sys->p_packetizer->fmt_out.video.i_frame_rate_base > 0 ) p_sys->i_dts += INT64_C(1000000) * p_sys->p_packetizer->fmt_out.video.i_frame_rate_base / p_sys->p_packetizer->fmt_out.video.i_frame_rate; else if( p_sys->f_fps > 0.001 ) p_sys->i_dts += (int64_t)((double)1000000.0 / p_sys->f_fps); else p_sys->i_dts += INT64_C(1000000) / 25; } } return 1; }
static void desktopResizeHandler( rdpContext *p_context ) { vlcrdp_context_t * p_vlccontext = (vlcrdp_context_t *) p_context; demux_sys_t *p_sys = p_vlccontext->p_demux->p_sys; rdpGdi *p_gdi = p_context->gdi; if ( p_sys->es ) { es_out_Del( p_vlccontext->p_demux->out, p_sys->es ); p_sys->es = NULL; } /* Now init and fill es format */ vlc_fourcc_t i_chroma; switch( p_gdi->bytesPerPixel ) { default: case 16: i_chroma = VLC_CODEC_RGB16; break; case 24: i_chroma = VLC_CODEC_RGB24; break; case 32: i_chroma = VLC_CODEC_RGB32; break; } es_format_t fmt; es_format_Init( &fmt, VIDEO_ES, i_chroma ); fmt.video.i_chroma = i_chroma; fmt.video.i_visible_width = fmt.video.i_width = p_gdi->width; fmt.video.i_visible_height = fmt.video.i_height = p_gdi->height; fmt.video.i_frame_rate_base = 1000; fmt.video.i_frame_rate = 1000 * p_sys->f_fps; p_sys->i_framebuffersize = p_gdi->width * p_gdi->height * p_gdi->bytesPerPixel; if ( p_sys->p_block ) p_sys->p_block = block_Realloc( p_sys->p_block, 0, p_sys->i_framebuffersize ); else p_sys->p_block = block_Alloc( p_sys->i_framebuffersize ); p_sys->es = es_out_Add( p_vlccontext->p_demux->out, &fmt ); }
static void output_mode_cb(void *data, struct wl_output *output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) { demux_t *demux = data; demux_sys_t *sys = demux->p_sys; msg_Dbg(demux, "output mode: 0x%08"PRIX32" %"PRId32"x%"PRId32 " %"PRId32"mHz%s", flags, width, height, refresh, (flags & WL_OUTPUT_MODE_CURRENT) ? " (current)" : ""); if (!(flags & WL_OUTPUT_MODE_CURRENT)) return; if (width <= sys->x || height <= sys->y) return; if (sys->es != NULL) es_out_Del(demux->out, sys->es); es_format_t fmt; es_format_Init(&fmt, VIDEO_ES, VLC_CODEC_RGB32); fmt.video.i_chroma = VLC_CODEC_RGB32; fmt.video.i_bits_per_pixel = 32; fmt.video.i_sar_num = fmt.video.i_sar_den = 1; fmt.video.i_frame_rate = lroundf(1000.f * sys->rate); fmt.video.i_frame_rate_base = 1000; fmt.video.i_width = width; if (sys->w != 0 && width > sys->w + sys->x) fmt.video.i_visible_width = sys->w; else fmt.video.i_visible_width = width - sys->x; if (sys->h != 0 && height > sys->h + sys->y) fmt.video.i_visible_height = sys->h; else fmt.video.i_visible_height = height - sys->y; fmt.video.i_height = fmt.video.i_visible_height; sys->es = es_out_Add(demux->out, &fmt); sys->width = width; sys->height = height; (void) output; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; if( !( p_block_in = stream_Block( p_demux->s, FLAC_PACKET_SIZE ) ) ) return 0; p_block_in->i_pts = p_block_in->i_dts = p_sys->b_start ? VLC_TS_0 : VLC_TS_INVALID; p_sys->b_start = false; while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, &p_block_in )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; p_block_out->p_next = NULL; if( p_sys->p_es == NULL ) { p_sys->p_packetizer->fmt_out.b_packetized = true; p_sys->p_packetizer->fmt_out.audio_replay_gain = p_sys->replay_gain; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); } p_sys->i_pts = p_block_out->i_dts - VLC_TS_0; /* Correct timestamp */ p_block_out->i_pts += p_sys->i_time_offset; p_block_out->i_dts += p_sys->i_time_offset; /* set PCR */ es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts ); es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; } } return 1; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; if( ( p_block_in = stream_Block( p_demux->s, H264_PACKET_SIZE ) ) == NULL ) { return 0; } /* m4v demuxer doesn't set pts/dts at all */ p_block_in->i_dts = 1; p_block_in->i_pts = 1; while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, &p_block_in )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; p_block_out->p_next = NULL; if( p_sys->p_es == NULL ) { p_sys->p_packetizer->fmt_out.b_packetized = VLC_TRUE; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); } es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_dts ); p_block_out->i_dts = p_sys->i_dts; p_block_out->i_pts = p_sys->i_dts; es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; p_sys->i_dts += (int64_t)((double)1000000.0 / p_sys->f_fps); } } return 1; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; bool b_eof = !( p_block_in = stream_Block( p_demux->s, FLAC_PACKET_SIZE ) ); if ( p_block_in ) { p_block_in->i_pts = p_block_in->i_dts = p_sys->b_start ? VLC_TS_0 : VLC_TS_INVALID; p_sys->b_start = false; } while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, (p_block_in) ? &p_block_in : NULL )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; p_block_out->p_next = NULL; if( p_sys->p_es == NULL ) { p_sys->p_packetizer->fmt_out.b_packetized = true; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); } p_sys->i_pts = p_block_out->i_dts; /* set PCR */ es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts ); es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; } } return !b_eof; }
/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/ static int Demux( demux_t *p_demux) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block_in, *p_block_out; if( ( p_block_in = stream_Block( p_demux->s, M4A_PACKET_SIZE ) ) == NULL ) { return 0; } p_block_in->i_pts = p_block_in->i_dts = p_sys->b_start ? 1 : 0; p_sys->b_start = VLC_FALSE; while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer, &p_block_in )) ) { while( p_block_out ) { block_t *p_next = p_block_out->p_next; if( p_sys->p_es == NULL ) { p_sys->p_packetizer->fmt_out.b_packetized = VLC_TRUE; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); } es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts ); p_block_out->p_next = NULL; es_out_Send( p_demux->out, p_sys->p_es, p_block_out ); p_block_out = p_next; } } return 1; }
int OpenDemux( vlc_object_t* p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; const uint8_t *p_peek; ssize_t i_peek = vlc_stream_Peek( p_demux->s, &p_peek, 2048 ); if( unlikely( i_peek <= 32 ) ) return VLC_EGENERIC; const char *psz_xml = (const char *) p_peek; size_t i_xml = i_peek; /* Try to probe without xml module/loading the full document */ char *psz_alloc = NULL; switch( GetQWBE(p_peek) ) { /* See RFC 3023 Part 4 */ case UINT64_C(0xFFFE3C003F007800): /* UTF16 BOM<? */ case UINT64_C(0xFFFE3C003F007400): /* UTF16 BOM<t */ case UINT64_C(0xFEFF003C003F0078): /* UTF16 BOM<? */ case UINT64_C(0xFEFF003C003F0074): /* UTF16 BOM<t */ psz_alloc = FromCharset( "UTF-16", p_peek, i_peek ); break; case UINT64_C(0x3C003F0078006D00): /* UTF16-LE <?xm */ case UINT64_C(0x3C003F0074007400): /* UTF16-LE <tt */ psz_alloc = FromCharset( "UTF-16LE", p_peek, i_peek ); break; case UINT64_C(0x003C003F0078006D): /* UTF16-BE <?xm */ case UINT64_C(0x003C003F00740074): /* UTF16-BE <tt */ psz_alloc = FromCharset( "UTF-16BE", p_peek, i_peek ); break; case UINT64_C(0xEFBBBF3C3F786D6C): /* UTF8 BOM<?xml */ case UINT64_C(0x3C3F786D6C207665): /* UTF8 <?xml ve */ case UINT64_C(0xEFBBBF3C74742078): /* UTF8 BOM<tt x*/ break; default: if(GetDWBE(p_peek) != UINT32_C(0x3C747420)) /* tt node without xml document marker */ return VLC_EGENERIC; } if( psz_alloc ) { psz_xml = psz_alloc; i_xml = strlen( psz_alloc ); } /* Simplified probing. Valid TTML must have a namespace declaration */ const char *psz_tt = strnstr( psz_xml, "tt ", i_xml ); if( !psz_tt || psz_tt == psz_xml || (psz_tt[-1] != ':' && psz_tt[-1] != '<') ) { free( psz_alloc ); return VLC_EGENERIC; } else { const char * const rgsz[] = { "=\"http://www.w3.org/ns/ttml\"", "=\"http://www.w3.org/2004/11/ttaf1\"", "=\"http://www.w3.org/2006/04/ttaf1\"", "=\"http://www.w3.org/2006/10/ttaf1\"", }; const char *psz_ns = NULL; for( size_t i=0; i<ARRAY_SIZE(rgsz) && !psz_ns; i++ ) { psz_ns = strnstr( psz_xml, rgsz[i], i_xml - (psz_tt - psz_xml) ); } free( psz_alloc ); if( !psz_ns ) return VLC_EGENERIC; } p_demux->p_sys = p_sys = calloc( 1, sizeof( *p_sys ) ); if( unlikely( p_sys == NULL ) ) return VLC_ENOMEM; p_sys->b_first_time = true; p_sys->temporal_extent.i_type = TT_TIMINGS_PARALLEL; tt_time_Init( &p_sys->temporal_extent.begin ); tt_time_Init( &p_sys->temporal_extent.end ); tt_time_Init( &p_sys->temporal_extent.dur ); p_sys->temporal_extent.begin.base = 0; p_sys->p_xml = xml_Create( p_demux ); if( !p_sys->p_xml ) goto error; p_sys->p_reader = xml_ReaderCreate( p_sys->p_xml, p_demux->s ); if( !p_sys->p_reader ) goto error; #ifndef TTML_DEMUX_DEBUG p_sys->p_reader->obj.flags |= OBJECT_FLAGS_QUIET; #endif if( ReadTTML( p_demux ) != VLC_SUCCESS ) goto error; tt_timings_Resolve( (tt_basenode_t *) p_sys->p_rootnode, &p_sys->temporal_extent, &p_sys->times.p_array, &p_sys->times.i_count ); #ifdef TTML_DEMUX_DEBUG { struct vlc_memstream stream; if( vlc_memstream_open( &stream ) ) goto error; tt_time_t t; tt_time_Init( &t ); tt_node_ToText( &stream, (tt_basenode_t*)p_sys->p_rootnode, &t /* invalid */ ); vlc_memstream_putc( &stream, '\0' ); if( vlc_memstream_close( &stream ) == VLC_SUCCESS ) { msg_Dbg( p_demux, "%s", stream.ptr ); free( stream.ptr ); } } #endif p_demux->pf_demux = Demux; p_demux->pf_control = Control; es_format_t fmt; es_format_Init( &fmt, SPU_ES, VLC_CODEC_TTML ); p_sys->p_es = es_out_Add( p_demux->out, &fmt ); if( !p_sys->p_es ) goto error; es_format_Clean( &fmt ); return VLC_SUCCESS; error: CloseDemux( p_demux ); return VLC_EGENERIC; }
/***************************************************************************** * Open: initializes demux structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; const uint8_t *p_peek; es_format_t fmt; if( stream_Peek( p_demux->s, &p_peek, 5 ) < 5 ) return VLC_EGENERIC; if( p_peek[0] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x00 || p_peek[3] != 0x01 || (p_peek[4]&0xFE) != 0x40 ) /* VPS & forbidden zero bit*/ { if( !p_demux->b_force ) { msg_Warn( p_demux, "hevc module discarded (no startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like a HEVC ES stream, " "continuing anyway" ); } p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); if( !p_demux->p_sys ) return VLC_ENOMEM; p_sys->p_es = NULL; p_sys->i_dts = VLC_TS_0; p_sys->f_force_fps = var_CreateGetFloat( p_demux, "hevc-force-fps" ); if( p_sys->f_force_fps != 0.0f ) { p_sys->f_fps = ( p_sys->f_force_fps < 0.001f )? 0.001f: p_sys->f_force_fps; msg_Dbg( p_demux, "using %.2f fps", (double) p_sys->f_fps ); } else p_sys->f_fps = 0.0f; /* Load the hevc packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_HEVC ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "hevc" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } p_sys->p_packetizer->fmt_out.b_packetized = true; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); if( !p_sys->p_es ) { demux_PacketizerDestroy( p_sys->p_packetizer ); free( p_sys ); return VLC_ENOMEM; } p_demux->pf_demux = Demux; p_demux->pf_control= Control; return VLC_SUCCESS; }
/***************************************************************************** * Open: initializes ES structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; byte_t *p_peek; int i_peek = 0; vlc_bool_t b_big_endian = 0; /* Arbitrary initialisation */ /* Check if we are dealing with a WAV file */ if( stream_Peek( p_demux->s, &p_peek, 12 ) == 12 && !memcmp( p_peek, "RIFF", 4 ) && !memcmp( p_peek + 8, "WAVE", 4 ) ) { int i_size; /* Skip the wave header */ i_peek = 12 + 8; while( stream_Peek( p_demux->s, &p_peek, i_peek ) == i_peek && memcmp( p_peek + i_peek - 8, "data", 4 ) ) { i_peek += GetDWLE( p_peek + i_peek - 4 ) + 8; } /* TODO: should check wave format and sample_rate */ /* Some A52 wav files don't begin with a sync code so we do a more * extensive search */ i_size = stream_Peek( p_demux->s, &p_peek, i_peek + A52_PACKET_SIZE * 2); i_size -= (PCM_FRAME_SIZE + A52_MAX_HEADER_SIZE); while( i_peek < i_size ) { if( CheckSync( p_peek + i_peek, &b_big_endian ) != VLC_SUCCESS ) /* The data is stored in 16 bits words */ i_peek += 2; else { /* Check following sync code */ if( CheckSync( p_peek + i_peek + PCM_FRAME_SIZE, &b_big_endian ) != VLC_SUCCESS ) { i_peek += 2; continue; } break; } } } /* Have a peep at the show. */ if( stream_Peek( p_demux->s, &p_peek, i_peek + A52_MAX_HEADER_SIZE * 2 ) < i_peek + A52_MAX_HEADER_SIZE * 2 ) { /* Stream too short */ msg_Warn( p_demux, "cannot peek()" ); return VLC_EGENERIC; } if( CheckSync( p_peek + i_peek, &b_big_endian ) != VLC_SUCCESS ) { if( strncmp( p_demux->psz_demux, "a52", 3 ) ) { return VLC_EGENERIC; } /* User forced */ msg_Err( p_demux, "this doesn't look like a A52 audio stream, " "continuing anyway" ); } /* Fill p_demux fields */ p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); p_sys->b_start = VLC_TRUE; p_sys->i_mux_rate = 0; p_sys->b_big_endian = b_big_endian; /* * Load the A52 packetizer */ p_sys->p_packetizer = vlc_object_create( p_demux, VLC_OBJECT_DECODER ); p_sys->p_packetizer->pf_decode_audio = 0; p_sys->p_packetizer->pf_decode_video = 0; p_sys->p_packetizer->pf_decode_sub = 0; p_sys->p_packetizer->pf_packetize = 0; /* Initialization of decoder structure */ es_format_Init( &p_sys->p_packetizer->fmt_in, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', ' ' ) ); p_sys->p_packetizer->p_module = module_Need( p_sys->p_packetizer, "packetizer", NULL, 0 ); if( !p_sys->p_packetizer->p_module ) { msg_Err( p_demux, "cannot find A52 packetizer" ); return VLC_EGENERIC; } /* Create one program */ p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_in ); return VLC_SUCCESS; }
void *codec_init (demux_t *demux, es_format_t *fmt) { if (fmt->i_cat == AUDIO_ES) aout_FormatPrepare (&fmt->audio); return es_out_Add (demux->out, fmt); }
/***************************************************************************** * Open: check file and initializes structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; int i_size; bool b_matched = false; if( IsMxpeg( p_demux->s ) && !p_demux->b_force ) // let avformat handle this case return VLC_EGENERIC; demux_sys_t *p_sys = (demux_sys_t *)malloc( sizeof( demux_sys_t ) ); // sunqueen modify if( unlikely(p_sys == NULL) ) return VLC_ENOMEM; p_demux->pf_control = Control; p_demux->p_sys = p_sys; p_sys->p_es = NULL; p_sys->i_time = VLC_TS_0; p_sys->i_level = 0; p_sys->psz_separator = NULL; p_sys->i_frame_size_estimate = 15 * 1024; char *content_type = stream_ContentType( p_demux->s ); if ( content_type ) { //FIXME: this is not fully match to RFC char* boundary = strstr( content_type, "boundary=" ); if( boundary ) { boundary += strlen( "boundary=" ); size_t len = strlen( boundary ); if( len > 2 && boundary[0] == '"' && boundary[len-1] == '"' ) { boundary[len-1] = '\0'; boundary++; } p_sys->psz_separator = strdup( boundary ); if( !p_sys->psz_separator ) { free( content_type ); goto error; } } free( content_type ); } b_matched = CheckMimeHeader( p_demux, &i_size); if( b_matched ) { p_demux->pf_demux = MimeDemux; stream_Read( p_demux->s, NULL, i_size ); } else if( i_size == 0 ) { /* 0xffd8 identify a JPEG SOI */ if( p_sys->p_peek[0] == 0xFF && p_sys->p_peek[1] == 0xD8 ) { msg_Dbg( p_demux, "JPEG SOI marker detected" ); p_demux->pf_demux = MjpgDemux; p_sys->i_level++; } else { goto error; } } else { goto error; } /* Frame rate */ float f_fps = var_InheritFloat( p_demux, "mjpeg-fps" ); p_sys->i_still_end = 0; if( demux_IsPathExtension( p_demux, ".jpeg" ) || demux_IsPathExtension( p_demux, ".jpg" ) ) { /* Plain JPEG file = single still picture */ p_sys->b_still = true; if( f_fps == 0.f ) /* Defaults to 1fps */ f_fps = 1.f; } else p_sys->b_still = false; p_sys->i_frame_length = f_fps ? (CLOCK_FREQ / f_fps) : 0; es_format_Init( &p_sys->fmt, VIDEO_ES, 0 ); p_sys->fmt.i_codec = VLC_CODEC_MJPG; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt ); return VLC_SUCCESS; error: free( p_sys->psz_separator ); free( p_sys ); return VLC_EGENERIC; }
static int Open(vlc_object_t *object) { demux_t *demux = (demux_t*)object; const uint8_t *peek; if (vlc_stream_Peek(demux->s, &peek, 11) != 11) return VLC_EGENERIC; bool is_stl_25 = !memcmp(&peek[3], "STL25.01", 8); bool is_stl_30 = !memcmp(&peek[3], "STL30.01", 8); if (!is_stl_25 && !is_stl_30) return VLC_EGENERIC; const double fps = is_stl_25 ? 25 : 30; uint8_t header[1024]; if (vlc_stream_Read(demux->s, header, sizeof(header)) != sizeof(header)) { msg_Err(demux, "Incomplete EBU STL header"); return VLC_EGENERIC; } const int cct = ParseInteger(&header[12], 2); const mtime_t program_start = ParseTextTimeCode(&header[256], fps); const int tti_count = ParseInteger(&header[238], 5); msg_Dbg(demux, "Detected EBU STL : CCT=%d TTI=%d start=%8.8s %"PRId64, cct, tti_count, &header[256], program_start); demux_sys_t *sys = xmalloc(sizeof(*sys)); sys->next_date = 0; sys->current = 0; sys->count = 0; sys->index = xcalloc(tti_count, sizeof(*sys->index)); bool comment = false; stl_entry_t *s = &sys->index[0]; s->count = 0; for (int i = 0; i < tti_count; i++) { uint8_t tti[16]; if (vlc_stream_Read(demux->s, tti, 16) != 16 || vlc_stream_Read(demux->s, NULL, 112) != 112) { msg_Warn(demux, "Incomplete EBU STL file"); break; } const int ebn = tti[3]; if (ebn >= 0xf0 && ebn <= 0xfd) continue; if (ebn == 0xfe) continue; if (s->count <= 0) { comment = tti[15] != 0; s->start = ParseTimeCode(&tti[5], fps) - program_start; s->stop = ParseTimeCode(&tti[9], fps) - program_start; s->index = i; } s->count++; if (ebn == 0xff && !comment) s = &sys->index[++sys->count]; if (ebn == 0xff && sys->count < tti_count) s->count = 0; } if (sys->count > 0) vlc_stream_Seek(demux->s, 1024 + 128LL * sys->index[0].index); es_format_t fmt; es_format_Init(&fmt, SPU_ES, VLC_CODEC_EBU_STL); fmt.i_extra = sizeof(header); fmt.p_extra = header; sys->es = es_out_Add(demux->out, &fmt); fmt.i_extra = 0; fmt.p_extra = NULL; es_format_Clean(&fmt); demux->p_sys = sys; demux->pf_demux = Demux; demux->pf_control = Control; return VLC_SUCCESS; }
/***************************************************************************** * Open: initializes demux structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; vlc_bool_t b_forced = VLC_FALSE; uint8_t *p_peek; es_format_t fmt; if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) { msg_Err( p_demux, "cannot peek" ); return VLC_EGENERIC; } if( !strncmp( p_demux->psz_demux, "mpgv", 4 ) ) { b_forced = VLC_TRUE; } if( p_peek[0] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x01 ) { if( !b_forced ) { msg_Warn( p_demux, "ES module discarded (no startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like an MPEG ES stream, continuing" ); } if( p_peek[3] > 0xb9 ) { if( !b_forced ) { msg_Warn( p_demux, "ES module discarded (system startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this seems to be a system stream (PS plug-in ?), but continuing" ); } p_demux->pf_demux = Demux; p_demux->pf_control= Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); p_sys->b_start = VLC_TRUE; p_sys->p_es = NULL; /* * Load the mpegvideo packetizer */ p_sys->p_packetizer = vlc_object_create( p_demux, VLC_OBJECT_PACKETIZER ); p_sys->p_packetizer->pf_decode_audio = NULL; p_sys->p_packetizer->pf_decode_video = NULL; p_sys->p_packetizer->pf_decode_sub = NULL; p_sys->p_packetizer->pf_packetize = NULL; es_format_Init( &p_sys->p_packetizer->fmt_in, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) ); es_format_Init( &p_sys->p_packetizer->fmt_out, UNKNOWN_ES, 0 ); p_sys->p_packetizer->p_module = module_Need( p_sys->p_packetizer, "packetizer", NULL, 0 ); if( p_sys->p_packetizer->p_module == NULL) { vlc_object_destroy( p_sys->p_packetizer ); msg_Err( p_demux, "cannot find mpgv packetizer" ); free( p_sys ); return VLC_EGENERIC; } /* * create the output */ es_format_Init( &fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) ); p_sys->p_es = es_out_Add( p_demux->out, &fmt ); return VLC_SUCCESS; }
static rfbBool mallocFrameBufferHandler( rfbClient* p_client ) { vlc_fourcc_t i_chroma; demux_t *p_demux = (demux_t *) rfbClientGetClientData( p_client, DemuxThread ); demux_sys_t *p_sys = p_demux->p_sys; if ( p_sys->es ) /* Source has changed resolution */ { es_out_Del( p_demux->out, p_sys->es ); p_sys->es = NULL; } int i_width = p_client->width; int i_height = p_client->height; int i_depth = p_client->format.bitsPerPixel; switch( i_depth ) { case 8: i_chroma = VLC_CODEC_RGB8; break; default: case 16: i_chroma = VLC_CODEC_RGB16; break; case 24: i_chroma = VLC_CODEC_RGB24; break; case 32: i_chroma = VLC_CODEC_RGB32; break; } switch( i_chroma ) { case VLC_CODEC_RGB16: p_client->format.redShift = 11; p_client->format.greenShift = 5; p_client->format.blueShift = 0; p_client->format.redMax = 0x1f; p_client->format.greenMax = 0x3f; p_client->format.blueMax = 0x1f; break; case VLC_CODEC_RGB24: case VLC_CODEC_RGB32: p_client->format.redShift = 16; p_client->format.greenShift = 8; p_client->format.blueShift = 0; p_client->format.redMax = 0xff; p_client->format.greenMax = 0xff; p_client->format.blueMax = 0xff; break; } /* Set up framebuffer */ p_sys->i_framebuffersize = i_width * i_height * i_depth / 8; /* Reuse unsent block */ if ( p_sys->p_block ) p_sys->p_block = block_Realloc( p_sys->p_block, 0, p_sys->i_framebuffersize ); else p_sys->p_block = block_Alloc( p_sys->i_framebuffersize ); if ( p_sys->p_block ) p_sys->p_block->i_buffer = p_sys->i_framebuffersize; else return FALSE; /* Push our VNC config */ SetFormatAndEncodings( p_client ); /* Now init and fill es format */ es_format_t fmt; es_format_Init( &fmt, VIDEO_ES, i_chroma ); /* Fill input format */ fmt.video.i_chroma = i_chroma; fmt.video.i_visible_width = fmt.video.i_width = i_width; fmt.video.i_visible_height = fmt.video.i_height = i_height; fmt.video.i_frame_rate_base = 1000; fmt.video.i_frame_rate = 1000 * p_sys->f_fps; fmt.video.i_bits_per_pixel = i_depth; fmt.video.i_rmask = p_client->format.redMax << p_client->format.redShift; fmt.video.i_gmask = p_client->format.greenMax << p_client->format.greenShift; fmt.video.i_bmask = p_client->format.blueMax << p_client->format.blueShift; fmt.video.i_sar_num = fmt.video.i_sar_den = 1; /* declare the new es */ p_sys->es = es_out_Add( p_demux->out, &fmt ); return TRUE; }
static int Open(vlc_object_t *object) { demux_t *demux = (demux_t*)object; /* Detect the image type */ const image_format_t *img; const uint8_t *peek; int peek_size = 0; for (int i = 0; ; i++) { img = &formats[i]; if (!img->codec) return VLC_EGENERIC; if (img->detect) { if (img->detect(demux->s)) break; } else { if (peek_size < img->marker_size) peek_size = stream_Peek(demux->s, &peek, img->marker_size); if (peek_size >= img->marker_size && !memcmp(peek, img->marker, img->marker_size)) break; } } msg_Dbg(demux, "Detected image: %s", vlc_fourcc_GetDescription(VIDEO_ES, img->codec)); if( img->codec == VLC_CODEC_MXPEG ) { return VLC_EGENERIC; //let avformat demux this file } /* Load and if selected decode */ es_format_t fmt; es_format_Init(&fmt, VIDEO_ES, img->codec); fmt.video.i_chroma = fmt.i_codec; block_t *data = Load(demux); if (data && var_InheritBool(demux, "image-decode")) { char *string = var_InheritString(demux, "image-chroma"); vlc_fourcc_t chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, string); free(string); data = Decode(demux, &fmt.video, chroma, data); fmt.i_codec = fmt.video.i_chroma; } fmt.i_id = var_InheritInteger(demux, "image-id"); fmt.i_group = var_InheritInteger(demux, "image-group"); if (var_InheritURational(demux, &fmt.video.i_frame_rate, &fmt.video.i_frame_rate_base, "image-fps") || fmt.video.i_frame_rate <= 0 || fmt.video.i_frame_rate_base <= 0) { msg_Err(demux, "Invalid frame rate, using 10/1 instead"); fmt.video.i_frame_rate = 10; fmt.video.i_frame_rate_base = 1; } /* If loadind failed, we still continue to avoid mis-detection * by other demuxers. */ if (!data) msg_Err(demux, "Failed to load the image"); /* */ demux_sys_t *sys = malloc(sizeof(*sys)); if (!sys) { if (data) block_Release(data); es_format_Clean(&fmt); return VLC_ENOMEM; } sys->data = data; sys->es = es_out_Add(demux->out, &fmt); sys->duration = CLOCK_FREQ * var_InheritFloat(demux, "image-duration"); sys->is_realtime = var_InheritBool(demux, "image-realtime"); sys->pts_origin = sys->is_realtime ? mdate() : 0; sys->pts_next = VLC_TS_INVALID; date_Init(&sys->pts, fmt.video.i_frame_rate, fmt.video.i_frame_rate_base); date_Set(&sys->pts, 0); es_format_Clean(&fmt); demux->pf_demux = Demux; demux->pf_control = Control; demux->p_sys = sys; return VLC_SUCCESS; }
/***************************************************************************** * Demux: *****************************************************************************/ static int Demux( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; int i_ret, i_mux_rate; block_t *p_pkt; i_ret = ps_pkt_resynch( p_demux->s, p_sys->format, p_sys->b_have_pack ); if( i_ret < 0 ) { return VLC_DEMUXER_EOF; } else if( i_ret == 0 ) { if( !p_sys->b_lost_sync ) { msg_Warn( p_demux, "garbage at input from %"PRIu64", trying to resync...", vlc_stream_Tell(p_demux->s) ); NotifyDiscontinuity( p_sys->tk, p_demux->out ); } p_sys->b_lost_sync = true; return VLC_DEMUXER_SUCCESS; } if( p_sys->b_lost_sync ) msg_Warn( p_demux, "found sync code" ); p_sys->b_lost_sync = false; if( p_sys->i_length == VLC_TICK_INVALID && p_sys->b_seekable ) { if( !FindLength( p_demux ) ) return VLC_DEMUXER_EGENERIC; } if( ( p_pkt = ps_pkt_read( p_demux->s ) ) == NULL ) { return VLC_DEMUXER_EOF; } if( p_pkt->i_buffer < 4 ) { block_Release( p_pkt ); return VLC_DEMUXER_EGENERIC; } const uint8_t i_stream_id = p_pkt->p_buffer[3]; switch( i_stream_id ) { case PS_STREAM_ID_END_STREAM: block_Release( p_pkt ); break; case PS_STREAM_ID_PACK_HEADER: if( !ps_pkt_parse_pack( p_pkt, &p_sys->i_pack_scr, &i_mux_rate ) ) { if( p_sys->i_first_scr == VLC_TICK_INVALID ) p_sys->i_first_scr = p_sys->i_pack_scr; CheckPCR( p_sys, p_demux->out, p_sys->i_pack_scr ); p_sys->i_scr = p_sys->i_pack_scr; p_sys->i_lastpack_byte = vlc_stream_Tell( p_demux->s ); if( !p_sys->b_have_pack ) p_sys->b_have_pack = true; /* done later on to work around bad vcd/svcd streams */ /* es_out_SetPCR( p_demux->out, p_sys->i_scr ); */ if( i_mux_rate > 0 ) p_sys->i_mux_rate = i_mux_rate; } block_Release( p_pkt ); break; case PS_STREAM_ID_SYSTEM_HEADER: if( !ps_pkt_parse_system( p_pkt, &p_sys->psm, p_sys->tk ) ) { int i; for( i = 0; i < PS_TK_COUNT; i++ ) { ps_track_t *tk = &p_sys->tk[i]; if( !tk->b_configured && tk->fmt.i_cat != UNKNOWN_ES ) { if( tk->b_seen ) tk->es = es_out_Add( p_demux->out, &tk->fmt ); /* else create when seeing packet */ tk->b_configured = true; } } } block_Release( p_pkt ); break; case PS_STREAM_ID_MAP: if( p_sys->psm.i_version == 0xFFFF ) msg_Dbg( p_demux, "contains a PSM"); ps_psm_fill( &p_sys->psm, p_pkt, p_sys->tk, p_demux->out ); block_Release( p_pkt ); break; default: /* Reject non video/audio nor PES */ if( i_stream_id < 0xC0 || i_stream_id > 0xEF ) { block_Release( p_pkt ); break; } /* fallthrough */ case PS_STREAM_ID_PRIVATE_STREAM1: case PS_STREAM_ID_EXTENDED: { int i_id = ps_pkt_id( p_pkt ); /* Small heuristic to improve MLP detection from AOB */ if( i_id == 0xa001 && p_sys->i_aob_mlp_count < 500 ) { p_sys->i_aob_mlp_count++; } else if( i_id == 0xbda1 && p_sys->i_aob_mlp_count > 0 ) { p_sys->i_aob_mlp_count--; i_id = 0xa001; } bool b_new = false; ps_track_t *tk = &p_sys->tk[ps_id_to_tk(i_id)]; if( !tk->b_configured ) { if( !ps_track_fill( tk, &p_sys->psm, i_id, p_pkt, false ) ) { /* No PSM and no probing yet */ if( p_sys->format == PSMF_PS ) { if( tk->fmt.i_cat == VIDEO_ES ) tk->fmt.i_codec = VLC_CODEC_H264; #if 0 if( i_stream_id == PS_STREAM_ID_PRIVATE_STREAM1 ) { es_format_Change( &tk->fmt, AUDIO_ES, VLC_CODEC_ATRAC3P ); tk->fmt.audio.i_blockalign = 376; tk->fmt.audio.i_channels = 2; tk->fmt.audio.i_rate = 44100; } #endif } tk->es = es_out_Add( p_demux->out, &tk->fmt ); b_new = true; tk->b_configured = true; } else { msg_Dbg( p_demux, "es id=0x%x format unknown", i_id ); } } /* Late creation from system header */ if( !tk->b_seen && tk->b_configured && !tk->es && tk->fmt.i_cat != UNKNOWN_ES ) tk->es = es_out_Add( p_demux->out, &tk->fmt ); tk->b_seen = true; /* The popular VCD/SVCD subtitling WinSubMux does not * renumber the SCRs when merging subtitles into the PES */ if( tk->b_seen && !p_sys->b_bad_scr && ( tk->fmt.i_codec == VLC_CODEC_OGT || tk->fmt.i_codec == VLC_CODEC_CVD ) ) { p_sys->b_bad_scr = true; p_sys->i_first_scr = VLC_TICK_INVALID; } if( p_sys->i_pack_scr != VLC_TICK_INVALID && !p_sys->b_bad_scr ) { if( (tk->fmt.i_cat == AUDIO_ES || tk->fmt.i_cat == VIDEO_ES) && tk->i_first_pts != VLC_TICK_INVALID && tk->i_first_pts - p_sys->i_pack_scr > VLC_TICK_FROM_SEC(2)) { msg_Warn( p_demux, "Incorrect SCR timing offset by of %"PRId64 "ms, disabling", MS_FROM_VLC_TICK(tk->i_first_pts - p_sys->i_pack_scr) ); p_sys->b_bad_scr = true; /* Disable Offset SCR */ p_sys->i_first_scr = VLC_TICK_INVALID; } else es_out_SetPCR( p_demux->out, p_sys->i_pack_scr ); } if( tk->b_configured && tk->es && !ps_pkt_parse_pes( VLC_OBJECT(p_demux), p_pkt, tk->i_skip ) ) { if( tk->fmt.i_cat == AUDIO_ES || tk->fmt.i_cat == VIDEO_ES ) { if( !p_sys->b_bad_scr && p_sys->i_pack_scr != VLC_TICK_INVALID && p_pkt->i_pts != VLC_TICK_INVALID && p_sys->i_pack_scr > p_pkt->i_pts + VLC_TICK_FROM_MS(250) ) { msg_Warn( p_demux, "Incorrect SCR timing in advance of %" PRId64 "ms, disabling", MS_FROM_VLC_TICK(p_sys->i_pack_scr - p_pkt->i_pts) ); p_sys->b_bad_scr = true; p_sys->i_first_scr = VLC_TICK_INVALID; } if( (p_sys->b_bad_scr || !p_sys->b_have_pack) && !p_sys->i_scr_track_id ) { p_sys->i_scr_track_id = tk->i_id; } } if( ((!b_new && !p_sys->b_have_pack) || p_sys->b_bad_scr) && p_sys->i_scr_track_id == tk->i_id && p_pkt->i_pts != VLC_TICK_INVALID ) { /* A hack to sync the A/V on PES files. */ msg_Dbg( p_demux, "force SCR: %"PRId64, p_pkt->i_pts ); CheckPCR( p_sys, p_demux->out, p_pkt->i_pts ); p_sys->i_scr = p_pkt->i_pts; if( p_sys->i_first_scr == VLC_TICK_INVALID ) p_sys->i_first_scr = p_sys->i_scr; es_out_SetPCR( p_demux->out, p_pkt->i_pts ); } if( tk->fmt.i_codec == VLC_CODEC_TELETEXT && p_pkt->i_pts == VLC_TICK_INVALID && p_sys->i_scr != VLC_TICK_INVALID ) { /* Teletext may have missing PTS (ETSI EN 300 472 Annexe A) * In this case use the last SCR + 40ms */ p_pkt->i_pts = p_sys->i_scr + VLC_TICK_FROM_MS(40); } if( p_pkt->i_pts > p_sys->i_current_pts ) { p_sys->i_current_pts = p_pkt->i_pts; } if( tk->i_next_block_flags ) { p_pkt->i_flags = tk->i_next_block_flags; tk->i_next_block_flags = 0; } #if 0 if( tk->fmt.i_codec == VLC_CODEC_ATRAC3P ) { p_pkt->p_buffer += 14; p_pkt->i_buffer -= 14; } #endif es_out_Send( p_demux->out, tk->es, p_pkt ); } else { block_Release( p_pkt ); } p_sys->i_pack_scr = VLC_TICK_INVALID; } break; } demux_UpdateTitleFromStream( p_demux ); return VLC_DEMUXER_SUCCESS; }
/***************************************************************************** * Open: initializes raw DV demux structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; int i_width=-1, i_height=-1; unsigned u_fps_num, u_fps_den; vlc_fourcc_t i_chroma = 0; unsigned int i_sar_num; unsigned int i_sar_den; const struct preset_t *p_preset = NULL; const uint8_t *p_peek; bool b_y4m = false; if( stream_Peek( p_demux->s, &p_peek, 9 ) == 9 ) { /* http://wiki.multimedia.cx/index.php?title=YUV4MPEG2 */ if( !strncmp( (char *)p_peek, "YUV4MPEG2", 9 ) ) { b_y4m = true; goto valid; } } if( !p_demux->b_force ) { /* guess preset based on file extension */ if( !p_demux->psz_file ) return VLC_EGENERIC; const char *psz_ext = strrchr( p_demux->psz_file, '.' ); if( !psz_ext ) return VLC_EGENERIC; psz_ext++; for( unsigned i = 0; p_presets[i].psz_ext ; i++ ) { if( !strcasecmp( psz_ext, p_presets[i].psz_ext ) ) { p_preset = &p_presets[i]; goto valid; } } return VLC_EGENERIC; } valid: p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->b_y4m = b_y4m; /* guess the parameters based on the preset */ if( p_preset ) { i_width = p_preset->i_width; i_height = p_preset->i_height; u_fps_num = p_preset->u_fps_num; u_fps_den = p_preset->u_fps_den; i_sar_num = p_preset->u_ar_num * p_preset->i_height; i_sar_den = p_preset->u_ar_den * p_preset->i_width; i_chroma = p_preset->i_chroma; } /* override presets if yuv4mpeg2 */ if( b_y4m ) { /* The string should start with "YUV4MPEG2" */ char *psz = stream_ReadLine( p_demux->s ); char *psz_buf; int a = 1; int b = 1; if( unlikely(psz == NULL) ) goto error; /* NB, it is not possible to handle interlaced here, since the * interlaced picture flags are in picture_t not block_t */ #define READ_FRAC( key, num, den ) do { \ psz_buf = strstr( psz+9, key );\ if( psz_buf )\ {\ char *end = strchr( psz_buf+1, ' ' );\ char *sep;\ if( end ) *end = '\0';\ sep = strchr( psz_buf+1, ':' );\ if( sep )\ {\ *sep = '\0';\ den = atoi( sep+1 );\ }\ else\ {\ den = 1;\ }\ num = atoi( psz_buf+2 );\ if( sep ) *sep = ':';\ if( end ) *end = ' ';\ } } while(0) READ_FRAC( " W", i_width, a ); READ_FRAC( " H", i_height, a ); READ_FRAC( " F", u_fps_num, u_fps_den ); READ_FRAC( " A", a, b ); #undef READ_FRAC if( b != 0 ) { i_sar_num = a; i_sar_den = b; } psz_buf = strstr( psz+9, " C" ); if( psz_buf ) { static const struct { const char *psz_name; vlc_fourcc_t i_fcc; } formats[] = { { "420jpeg", VLC_CODEC_I420 }, { "420paldv", VLC_CODEC_I420 }, { "420", VLC_CODEC_I420 }, { "422", VLC_CODEC_I422 }, { "444", VLC_CODEC_I444 }, { "mono", VLC_CODEC_GREY }, { NULL, 0 } }; bool b_found = false; char *psz_end = strchr( psz_buf+1, ' ' ); if( psz_end ) *psz_end = '\0'; psz_buf += 2; for( int i = 0; formats[i].psz_name != NULL; i++ ) { if( !strncmp( psz_buf, formats[i].psz_name, strlen(formats[i].psz_name) ) ) { i_chroma = formats[i].i_fcc; b_found = true; break; } } if( !b_found ) msg_Warn( p_demux, "Unknown YUV4MPEG2 chroma type \"%s\"", psz_buf ); if( psz_end ) *psz_end = ' '; } free( psz ); } /* allow the user to override anything guessed from the input */ int i_tmp; i_tmp = var_CreateGetInteger( p_demux, "rawvid-width" ); if( i_tmp ) i_width = i_tmp; i_tmp = var_CreateGetInteger( p_demux, "rawvid-height" ); if( i_tmp ) i_height = i_tmp; char *psz_tmp; psz_tmp = var_CreateGetNonEmptyString( p_demux, "rawvid-chroma" ); if( psz_tmp ) { if( strlen( psz_tmp ) != 4 ) { msg_Err( p_demux, "Invalid fourcc format/chroma specification %s" " expecting four characters eg, UYVY", psz_tmp ); free( psz_tmp ); goto error; } memcpy( &i_chroma, psz_tmp, 4 ); msg_Dbg( p_demux, "Forcing chroma to 0x%.8x (%4.4s)", i_chroma, (char*)&i_chroma ); free( psz_tmp ); } if( var_InheritURational( p_demux, &u_fps_num, &u_fps_den, "rawvid-fps" ) ) { u_fps_num = 0; u_fps_den = 1; } if( var_InheritURational( p_demux, &i_sar_num, &i_sar_den, "rawvid-aspect-ratio" ) ) i_sar_num = i_sar_den = 1; /* moan about anything wrong */ if( i_width <= 0 || i_height <= 0 ) { msg_Err( p_demux, "width and height must be strictly positive." ); goto error; } if( !u_fps_num || !u_fps_den ) { msg_Err( p_demux, "invalid or no framerate specified." ); goto error; } if( i_chroma == 0 ) { msg_Err( p_demux, "invalid or no chroma specified." ); goto error; } /* fixup anything missing with sensible assumptions */ if( i_sar_num <= 0 || i_sar_den <= 0 ) { /* assume 1:1 sar */ i_sar_num = 1; i_sar_den = 1; } es_format_Init( &p_sys->fmt_video, VIDEO_ES, i_chroma ); video_format_Setup( &p_sys->fmt_video.video, i_chroma, i_width, i_height, i_width, i_height, i_sar_num, i_sar_den ); vlc_ureduce( &p_sys->fmt_video.video.i_frame_rate, &p_sys->fmt_video.video.i_frame_rate_base, u_fps_num, u_fps_den, 0); date_Init( &p_sys->pcr, p_sys->fmt_video.video.i_frame_rate, p_sys->fmt_video.video.i_frame_rate_base ); date_Set( &p_sys->pcr, 0 ); if( !p_sys->fmt_video.video.i_bits_per_pixel ) { msg_Err( p_demux, "Unsupported chroma 0x%.8x (%4.4s)", i_chroma, (char*)&i_chroma ); goto error; } p_sys->frame_size = i_width * i_height * p_sys->fmt_video.video.i_bits_per_pixel / 8; p_sys->p_es_video = es_out_Add( p_demux->out, &p_sys->fmt_video ); p_demux->pf_demux = Demux; p_demux->pf_control = Control; return VLC_SUCCESS; error: stream_Seek( p_demux->s, 0 ); // Workaround, but y4m uses stream_ReadLines free( p_sys ); return VLC_EGENERIC; }
static int Open (vlc_object_t *obj) { demux_t *demux = (demux_t *)obj; demux_sys_t *sys = vlc_obj_malloc(obj, sizeof (*sys)); if (unlikely(sys == NULL)) return VLC_ENOMEM; /* Open the device */ const char *device = demux->psz_location; if (device == NULL || !device[0]) device = "default"; const int mode = SND_PCM_NONBLOCK /*| SND_PCM_NO_AUTO_RESAMPLE*/ | SND_PCM_NO_AUTO_CHANNELS /*| SND_PCM_NO_AUTO_FORMAT*/; snd_pcm_t *pcm; int val = snd_pcm_open (&pcm, device, SND_PCM_STREAM_CAPTURE, mode); if (val != 0) { msg_Err (demux, "cannot open ALSA device \"%s\": %s", device, snd_strerror (val)); return VLC_EGENERIC; } sys->pcm = pcm; msg_Dbg (demux, "using ALSA device: %s", device); DumpDevice (VLC_OBJECT(demux), pcm); /* Negotiate capture parameters */ snd_pcm_hw_params_t *hw; es_format_t fmt; unsigned param; int dir; snd_pcm_hw_params_alloca (&hw); snd_pcm_hw_params_any (pcm, hw); Dump (demux, "initial hardware setup:\n", snd_pcm_hw_params_dump, hw); val = snd_pcm_hw_params_set_rate_resample (pcm, hw, 0); if (val) { msg_Err (demux, "cannot disable resampling: %s", snd_strerror (val)); goto error; } val = snd_pcm_hw_params_set_access (pcm, hw, SND_PCM_ACCESS_RW_INTERLEAVED); if (val) { msg_Err (demux, "cannot set access mode: %s", snd_strerror (val)); goto error; } snd_pcm_format_t format = SND_PCM_FORMAT_UNKNOWN; for (size_t i = 0; i < sizeof (choices) / sizeof (choices[0]); i++) if (snd_pcm_hw_params_test_format (pcm, hw, choices[i]) == 0) { val = snd_pcm_hw_params_set_format (pcm, hw, choices[i]); if (val) { msg_Err (demux, "cannot set sample format: %s", snd_strerror (val)); goto error; } format = choices[i]; break; } if (format == SND_PCM_FORMAT_UNKNOWN) { msg_Err (demux, "no supported sample format"); goto error; } assert ((size_t)format < (sizeof (formats) / sizeof (formats[0]))); es_format_Init (&fmt, AUDIO_ES, formats[format]); fmt.audio.i_format = fmt.i_codec; param = 1 + var_InheritBool (demux, "alsa-stereo"); val = snd_pcm_hw_params_set_channels_max (pcm, hw, ¶m); if (val) { msg_Err (demux, "cannot restrict channels count: %s", snd_strerror (val)); goto error; } val = snd_pcm_hw_params_set_channels_last (pcm, hw, ¶m); if (val) { msg_Err (demux, "cannot set channels count: %s", snd_strerror (val)); goto error; } assert (param > 0); assert (param < (sizeof (channel_maps) / sizeof (channel_maps[0]))); fmt.audio.i_channels = param; fmt.audio.i_physical_channels = channel_maps[param - 1]; param = var_InheritInteger (demux, "alsa-samplerate"); val = snd_pcm_hw_params_set_rate_max (pcm, hw, ¶m, NULL); if (val) { msg_Err (demux, "cannot restrict rate to %u Hz or less: %s", 192000, snd_strerror (val)); goto error; } val = snd_pcm_hw_params_set_rate_last (pcm, hw, ¶m, &dir); if (val) { msg_Err (demux, "cannot set sample rate: %s", snd_strerror (val)); goto error; } if (dir) msg_Warn (demux, "sample rate is not integral"); fmt.audio.i_rate = param; sys->rate = param; sys->start = mdate (); sys->caching = INT64_C(1000) * var_InheritInteger (demux, "live-caching"); param = sys->caching; val = snd_pcm_hw_params_set_buffer_time_near (pcm, hw, ¶m, NULL); if (val) { msg_Err (demux, "cannot set buffer duration: %s", snd_strerror (val)); goto error; } param /= 4; val = snd_pcm_hw_params_set_period_time_near (pcm, hw, ¶m, NULL); if (val) { msg_Err (demux, "cannot set period: %s", snd_strerror (val)); goto error; } val = snd_pcm_hw_params_get_period_size (hw, &sys->period_size, &dir); if (val) { msg_Err (demux, "cannot get period size: %s", snd_strerror (val)); goto error; } if (dir > 0) sys->period_size++; /* Commit hardware parameters */ val = snd_pcm_hw_params (pcm, hw); if (val) { msg_Err (demux, "cannot commit hardware parameters: %s", snd_strerror (val)); goto error; } Dump (demux, "final HW setup:\n", snd_pcm_hw_params_dump, hw); /* Kick recording */ aout_FormatPrepare (&fmt.audio); sys->es = es_out_Add (demux->out, &fmt); demux->p_sys = sys; if (vlc_clone (&sys->thread, Thread, demux, VLC_THREAD_PRIORITY_INPUT)) { es_out_Del (demux->out, sys->es); goto error; } demux->pf_demux = NULL; demux->pf_control = Control; return VLC_SUCCESS; error: snd_pcm_close (pcm); return VLC_EGENERIC; }
/***************************************************************************** * Open: check file and initializes structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; int i_size; bool b_matched = false; float f_fps; p_sys = malloc( sizeof( demux_sys_t ) ); if( unlikely(p_sys == NULL) ) return VLC_ENOMEM; p_demux->pf_control = Control; p_demux->p_sys = p_sys; p_sys->p_es = NULL; p_sys->i_time = 0; p_sys->i_level = 0; p_sys->psz_separator = NULL; p_sys->i_frame_size_estimate = 15 * 1024; b_matched = CheckMimeHeader( p_demux, &i_size); if( b_matched ) { p_demux->pf_demux = MimeDemux; stream_Read( p_demux->s, NULL, i_size ); } else if( 0 == i_size ) { /* 0xffd8 identify a JPEG SOI */ if( p_sys->p_peek[0] == 0xFF && p_sys->p_peek[1] == 0xD8 ) { msg_Dbg( p_demux, "JPEG SOI marker detected" ); p_demux->pf_demux = MjpgDemux; p_sys->i_level++; } else { goto error; } } else { goto error; } f_fps = var_CreateGetFloat( p_demux, "mjpeg-fps" ); p_sys->i_frame_length = 0; /* Check for jpeg file extension */ p_sys->b_still = false; p_sys->i_still_end = 0; if( demux_IsPathExtension( p_demux, ".jpeg" ) || demux_IsPathExtension( p_demux, ".jpg" ) ) { p_sys->b_still = true; if( f_fps ) { p_sys->i_still_length = 1000000.0 / f_fps; } else { /* Defaults to 1fps */ p_sys->i_still_length = 1000000; } } else if ( f_fps ) { p_sys->i_frame_length = 1000000.0 / f_fps; } es_format_Init( &p_sys->fmt, VIDEO_ES, 0 ); p_sys->fmt.i_codec = VLC_CODEC_MJPG; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt ); return VLC_SUCCESS; error: free( p_sys ); return VLC_EGENERIC; }
int avformat_OpenDemux( vlc_object_t *p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; AVInputFormat *fmt = NULL; vlc_tick_t i_start_time = VLC_TICK_INVALID; bool b_can_seek; const char *psz_url; int error; if( p_demux->psz_filepath ) psz_url = p_demux->psz_filepath; else psz_url = p_demux->psz_url; if( avformat_ProbeDemux( p_this, &fmt, psz_url ) != VLC_SUCCESS ) return VLC_EGENERIC; vlc_stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_can_seek ); /* Fill p_demux fields */ p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->ic = 0; p_sys->fmt = fmt; p_sys->tracks = NULL; p_sys->i_ssa_order = 0; TAB_INIT( p_sys->i_attachments, p_sys->attachments); p_sys->p_title = NULL; p_sys->i_seekpoint = 0; p_sys->i_update = 0; /* Create I/O wrapper */ unsigned char * p_io_buffer = av_malloc( AVFORMAT_IOBUFFER_SIZE ); if( !p_io_buffer ) { avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->ic = avformat_alloc_context(); if( !p_sys->ic ) { av_free( p_io_buffer ); avformat_CloseDemux( p_this ); return VLC_ENOMEM; } AVIOContext *pb = p_sys->ic->pb = avio_alloc_context( p_io_buffer, AVFORMAT_IOBUFFER_SIZE, 0, p_demux, IORead, NULL, IOSeek ); if( !pb ) { av_free( p_io_buffer ); avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->ic->pb->seekable = b_can_seek ? AVIO_SEEKABLE_NORMAL : 0; error = avformat_open_input(&p_sys->ic, psz_url, p_sys->fmt, NULL); if( error < 0 ) { msg_Err( p_demux, "Could not open %s: %s", psz_url, vlc_strerror_c(AVUNERROR(error)) ); av_free( pb->buffer ); av_free( pb ); p_sys->ic = NULL; avformat_CloseDemux( p_this ); return VLC_EGENERIC; } char *psz_opts = var_InheritString( p_demux, "avformat-options" ); unsigned nb_streams = p_sys->ic->nb_streams; AVDictionary *options[nb_streams ? nb_streams : 1]; options[0] = NULL; for (unsigned i = 1; i < nb_streams; i++) options[i] = NULL; if (psz_opts) { vlc_av_get_options(psz_opts, &options[0]); for (unsigned i = 1; i < nb_streams; i++) { av_dict_copy(&options[i], options[0], 0); } free(psz_opts); } vlc_avcodec_lock(); /* avformat calls avcodec behind our back!!! */ error = avformat_find_stream_info( p_sys->ic, options ); vlc_avcodec_unlock(); AVDictionaryEntry *t = NULL; while ((t = av_dict_get(options[0], "", t, AV_DICT_IGNORE_SUFFIX))) { msg_Err( p_demux, "Unknown option \"%s\"", t->key ); } av_dict_free(&options[0]); for (unsigned i = 1; i < nb_streams; i++) { av_dict_free(&options[i]); } nb_streams = p_sys->ic->nb_streams; /* it may have changed */ if( !nb_streams ) { msg_Err( p_demux, "No streams found"); avformat_CloseDemux( p_this ); return VLC_EGENERIC; } p_sys->tracks = calloc( nb_streams, sizeof(*p_sys->tracks) ); if( !p_sys->tracks ) { avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->i_tracks = nb_streams; if( error < 0 ) { msg_Warn( p_demux, "Could not find stream info: %s", vlc_strerror_c(AVUNERROR(error)) ); } for( unsigned i = 0; i < nb_streams; i++ ) { struct avformat_track_s *p_track = &p_sys->tracks[i]; AVStream *s = p_sys->ic->streams[i]; const AVCodecParameters *cp = s->codecpar; es_format_t es_fmt; const char *psz_type = "unknown"; /* Do not use the cover art as a stream */ if( s->disposition == AV_DISPOSITION_ATTACHED_PIC ) continue; vlc_fourcc_t fcc = GetVlcFourcc( cp->codec_id ); switch( cp->codec_type ) { case AVMEDIA_TYPE_AUDIO: es_format_Init( &es_fmt, AUDIO_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); es_fmt.i_bitrate = cp->bit_rate; es_fmt.audio.i_channels = cp->channels; es_fmt.audio.i_rate = cp->sample_rate; es_fmt.audio.i_bitspersample = cp->bits_per_coded_sample; es_fmt.audio.i_blockalign = cp->block_align; psz_type = "audio"; if(cp->codec_id == AV_CODEC_ID_AAC_LATM) { es_fmt.i_original_fourcc = VLC_FOURCC('L','A','T','M'); es_fmt.b_packetized = false; } else if(cp->codec_id == AV_CODEC_ID_AAC && p_sys->fmt->long_name && strstr(p_sys->fmt->long_name, "raw ADTS AAC")) { es_fmt.i_original_fourcc = VLC_FOURCC('A','D','T','S'); es_fmt.b_packetized = false; } break; case AVMEDIA_TYPE_VIDEO: es_format_Init( &es_fmt, VIDEO_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); es_fmt.video.i_bits_per_pixel = cp->bits_per_coded_sample; /* Special case for raw video data */ if( cp->codec_id == AV_CODEC_ID_RAWVIDEO ) { msg_Dbg( p_demux, "raw video, pixel format: %i", cp->format ); if( GetVlcChroma( &es_fmt.video, cp->format ) != VLC_SUCCESS) { msg_Err( p_demux, "was unable to find a FourCC match for raw video" ); } else es_fmt.i_codec = es_fmt.video.i_chroma; } /* We need this for the h264 packetizer */ else if( cp->codec_id == AV_CODEC_ID_H264 && ( p_sys->fmt == av_find_input_format("flv") || p_sys->fmt == av_find_input_format("matroska") || p_sys->fmt == av_find_input_format("mp4") ) ) es_fmt.i_original_fourcc = VLC_FOURCC( 'a', 'v', 'c', '1' ); es_fmt.video.i_width = cp->width; es_fmt.video.i_height = cp->height; es_fmt.video.i_visible_width = es_fmt.video.i_width; es_fmt.video.i_visible_height = es_fmt.video.i_height; get_rotation(&es_fmt, s); # warning FIXME: implement palette transmission psz_type = "video"; AVRational rate; #if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */ # if (LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(55, 20, 0)) rate.num = s->time_base.num; rate.den = s->time_base.den; # else rate.num = s->codec->time_base.num; rate.den = s->codec->time_base.den; # endif rate.den *= __MAX( s->codec->ticks_per_frame, 1 ); #else /* ffmpeg */ rate = av_guess_frame_rate( p_sys->ic, s, NULL ); #endif if( rate.den && rate.num ) { es_fmt.video.i_frame_rate = rate.num; es_fmt.video.i_frame_rate_base = rate.den; } AVRational ar; #if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */ ar.num = s->sample_aspect_ratio.num; ar.den = s->sample_aspect_ratio.den; #else ar = av_guess_sample_aspect_ratio( p_sys->ic, s, NULL ); #endif if( ar.num && ar.den ) { es_fmt.video.i_sar_den = ar.den; es_fmt.video.i_sar_num = ar.num; } break; case AVMEDIA_TYPE_SUBTITLE: es_format_Init( &es_fmt, SPU_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); if( strncmp( p_sys->ic->iformat->name, "matroska", 8 ) == 0 && cp->codec_id == AV_CODEC_ID_DVD_SUBTITLE && cp->extradata != NULL && cp->extradata_size > 0 ) { char *psz_start; char *psz_buf = malloc( cp->extradata_size + 1); if( psz_buf != NULL ) { memcpy( psz_buf, cp->extradata , cp->extradata_size ); psz_buf[cp->extradata_size] = '\0'; psz_start = strstr( psz_buf, "size:" ); if( psz_start && vobsub_size_parse( psz_start, &es_fmt.subs.spu.i_original_frame_width, &es_fmt.subs.spu.i_original_frame_height ) == VLC_SUCCESS ) { msg_Dbg( p_demux, "original frame size: %dx%d", es_fmt.subs.spu.i_original_frame_width, es_fmt.subs.spu.i_original_frame_height ); } else { msg_Warn( p_demux, "reading original frame size failed" ); } psz_start = strstr( psz_buf, "palette:" ); if( psz_start && vobsub_palette_parse( psz_start, &es_fmt.subs.spu.palette[1] ) == VLC_SUCCESS ) { es_fmt.subs.spu.palette[0] = SPU_PALETTE_DEFINED; msg_Dbg( p_demux, "vobsub palette read" ); } else { msg_Warn( p_demux, "reading original palette failed" ); } free( psz_buf ); } } else if( cp->codec_id == AV_CODEC_ID_DVB_SUBTITLE && cp->extradata_size > 3 ) { es_fmt.subs.dvb.i_id = GetWBE( cp->extradata ) | (GetWBE( cp->extradata + 2 ) << 16); } else if( cp->codec_id == AV_CODEC_ID_MOV_TEXT ) { if( cp->extradata_size && (es_fmt.p_extra = malloc(cp->extradata_size)) ) { memcpy( es_fmt.p_extra, cp->extradata, cp->extradata_size ); es_fmt.i_extra = cp->extradata_size; } } psz_type = "subtitle"; break; default: es_format_Init( &es_fmt, UNKNOWN_ES, 0 ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); #ifdef HAVE_AVUTIL_CODEC_ATTACHMENT if( cp->codec_type == AVMEDIA_TYPE_ATTACHMENT ) { input_attachment_t *p_attachment; psz_type = "attachment"; if( cp->codec_id == AV_CODEC_ID_TTF ) { AVDictionaryEntry *filename = av_dict_get( s->metadata, "filename", NULL, 0 ); if( filename && filename->value ) { p_attachment = vlc_input_attachment_New( filename->value, "application/x-truetype-font", NULL, cp->extradata, (int)cp->extradata_size ); if( p_attachment ) TAB_APPEND( p_sys->i_attachments, p_sys->attachments, p_attachment ); } } else msg_Warn( p_demux, "unsupported attachment type (%u) in avformat demux", cp->codec_id ); } else #endif { if( cp->codec_type == AVMEDIA_TYPE_DATA ) psz_type = "data"; msg_Warn( p_demux, "unsupported track type (%u:%u) in avformat demux", cp->codec_type, cp->codec_id ); } break; } AVDictionaryEntry *language = av_dict_get( s->metadata, "language", NULL, 0 ); if ( language && language->value ) es_fmt.psz_language = strdup( language->value ); if( s->disposition & AV_DISPOSITION_DEFAULT ) es_fmt.i_priority = ES_PRIORITY_SELECTABLE_MIN + 1000; #ifdef HAVE_AVUTIL_CODEC_ATTACHMENT if( cp->codec_type != AVMEDIA_TYPE_ATTACHMENT ) #endif if( cp->codec_type != AVMEDIA_TYPE_DATA ) { const bool b_ogg = !strcmp( p_sys->fmt->name, "ogg" ); const uint8_t *p_extra = cp->extradata; unsigned i_extra = cp->extradata_size; if( cp->codec_id == AV_CODEC_ID_THEORA && b_ogg ) { unsigned pi_size[3]; const void *pp_data[3]; unsigned i_count; for( i_count = 0; i_count < 3; i_count++ ) { if( i_extra < 2 ) break; pi_size[i_count] = GetWBE( p_extra ); pp_data[i_count] = &p_extra[2]; if( i_extra < pi_size[i_count] + 2 ) break; p_extra += 2 + pi_size[i_count]; i_extra -= 2 + pi_size[i_count]; } if( i_count > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, i_count ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->codec_id == AV_CODEC_ID_SPEEX && b_ogg ) { const uint8_t p_dummy_comment[] = { 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned pi_size[2]; const void *pp_data[2]; pi_size[0] = i_extra; pp_data[0] = p_extra; pi_size[1] = sizeof(p_dummy_comment); pp_data[1] = p_dummy_comment; if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, 2 ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->codec_id == AV_CODEC_ID_OPUS ) { const uint8_t p_dummy_comment[] = { 'O', 'p', 'u', 's', 'T', 'a', 'g', 's', 0, 0, 0, 0, /* Vendor String length */ /* Vendor String */ 0, 0, 0, 0, /* User Comment List Length */ }; unsigned pi_size[2]; const void *pp_data[2]; pi_size[0] = i_extra; pp_data[0] = p_extra; pi_size[1] = sizeof(p_dummy_comment); pp_data[1] = p_dummy_comment; if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, 2 ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->extradata_size > 0 && !es_fmt.i_extra ) { es_fmt.p_extra = malloc( i_extra ); if( es_fmt.p_extra ) { es_fmt.i_extra = i_extra; memcpy( es_fmt.p_extra, p_extra, i_extra ); } } p_track->p_es = es_out_Add( p_demux->out, &es_fmt ); if( p_track->p_es && (s->disposition & AV_DISPOSITION_DEFAULT) ) es_out_Control( p_demux->out, ES_OUT_SET_ES_DEFAULT, p_track->p_es ); msg_Dbg( p_demux, "adding es: %s codec = %4.4s (%d)", psz_type, (char*)&fcc, cp->codec_id ); } es_format_Clean( &es_fmt ); } if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE ) i_start_time = FROM_AV_TS(p_sys->ic->start_time); msg_Dbg( p_demux, "AVFormat(%s %s) supported stream", AVPROVIDER(LIBAVFORMAT), LIBAVFORMAT_IDENT ); msg_Dbg( p_demux, " - format = %s (%s)", p_sys->fmt->name, p_sys->fmt->long_name ); msg_Dbg( p_demux, " - start time = %"PRId64, i_start_time ); msg_Dbg( p_demux, " - duration = %"PRId64, ( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ? FROM_AV_TS(p_sys->ic->duration) : -1 ); if( p_sys->ic->nb_chapters > 0 ) { p_sys->p_title = vlc_input_title_New(); p_sys->p_title->i_length = FROM_AV_TS(p_sys->ic->duration); } for( unsigned i = 0; i < p_sys->ic->nb_chapters; i++ ) { seekpoint_t *s = vlc_seekpoint_New(); AVDictionaryEntry *title = av_dict_get( p_sys->ic->metadata, "title", NULL, 0); if( title && title->value ) { s->psz_name = strdup( title->value ); EnsureUTF8( s->psz_name ); msg_Dbg( p_demux, " - chapter %d: %s", i, s->psz_name ); } s->i_time_offset = vlc_tick_from_samples( p_sys->ic->chapters[i]->start * p_sys->ic->chapters[i]->time_base.num, p_sys->ic->chapters[i]->time_base.den ) - (i_start_time != VLC_TICK_INVALID ? i_start_time : 0 ); TAB_APPEND( p_sys->p_title->i_seekpoint, p_sys->p_title->seekpoint, s ); } ResetTime( p_demux, 0 ); return VLC_SUCCESS; }
/***************************************************************************** * Open: initializes ES structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; const uint8_t *p_peek; es_format_t fmt; /* Have a peep at the show. */ if( vlc_stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC; if( p_peek[0]!='f' || p_peek[1]!='L' || p_peek[2]!='a' || p_peek[3]!='C' ) { if( !p_demux->obj.force && !demux_IsContentType( p_demux, "audio/flac" ) ) return VLC_EGENERIC; /* User forced */ msg_Err( p_demux, "this doesn't look like a flac stream, " "continuing anyway" ); } p_sys = malloc( sizeof( demux_sys_t ) ); if( unlikely(p_sys == NULL) ) return VLC_ENOMEM; p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys; p_sys->b_start = true; p_sys->i_next_block_flags = 0; p_sys->p_packetizer = NULL; p_sys->p_meta = NULL; p_sys->i_length = 0; p_sys->i_pts = VLC_TS_INVALID; p_sys->p_es = NULL; p_sys->p_current_block = NULL; TAB_INIT( p_sys->i_seekpoint, p_sys->seekpoint ); TAB_INIT( p_sys->i_attachments, p_sys->attachments); TAB_INIT( p_sys->i_title_seekpoints, p_sys->pp_title_seekpoints ); p_sys->i_cover_idx = 0; p_sys->i_cover_score = 0; es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_FLAC ); /* We need to read and store the STREAMINFO metadata into fmt extra */ if( ParseHeaders( p_demux, &fmt ) ) goto error; /* Load the FLAC packetizer */ p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "flac" ); if( !p_sys->p_packetizer ) goto error; if( p_sys->i_cover_idx < p_sys->i_attachments ) { char psz_url[128]; if( !p_sys->p_meta ) p_sys->p_meta = vlc_meta_New(); snprintf( psz_url, sizeof(psz_url), "attachment://%s", p_sys->attachments[p_sys->i_cover_idx]->psz_name ); vlc_meta_Set( p_sys->p_meta, vlc_meta_ArtworkURL, psz_url ); } p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_in ); if( !p_sys->p_es ) goto error; return VLC_SUCCESS; error: Close( p_this ); return VLC_EGENERIC; }
/***************************************************************************** * Open: check file and initializes structures *****************************************************************************/ static int Open( vlc_object_t *p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; uint8_t hdr[20]; const uint8_t *p_peek; int i_cat; int i_samples, i_modulo; if( stream_Peek( p_demux->s , &p_peek, 4 ) < 4 ) return VLC_EGENERIC; if( memcmp( p_peek, ".snd", 4 ) ) return VLC_EGENERIC; /* skip signature */ stream_Read( p_demux->s, NULL, 4 ); /* cannot fail */ /* read header */ if( stream_Read( p_demux->s, hdr, 20 ) < 20 ) { msg_Err( p_demux, "cannot read" ); return VLC_EGENERIC; } if( GetDWBE( &hdr[0] ) < 24 ) { msg_Err( p_demux, "invalid file" ); return VLC_EGENERIC; } DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys; p_sys->i_time = 0; p_sys->i_header_size = GetDWBE( &hdr[0] ); /* skip extra header data */ if( p_sys->i_header_size > 24 ) { stream_Read( p_demux->s, NULL, p_sys->i_header_size - 24 ); } /* init fmt */ es_format_Init( &p_sys->fmt, AUDIO_ES, 0 ); p_sys->fmt.audio.i_rate = GetDWBE( &hdr[12] ); p_sys->fmt.audio.i_channels = GetDWBE( &hdr[16] ); #if 0 p_sys->au.i_header_size = GetDWBE( &p_sys->au.i_header_size ); p_sys->au.i_data_size = GetDWBE( &p_sys->au.i_data_size ); p_sys->au.i_encoding = GetDWBE( &p_sys->au.i_encoding ); p_sys->au.i_sample_rate = GetDWBE( &p_sys->au.i_sample_rate ); p_sys->au.i_channels = GetDWBE( &p_sys->au.i_channels ); #endif switch( GetDWBE( &hdr[8] ) ) { case AU_ALAW_8: /* 8-bit ISDN A-law */ p_sys->fmt.i_codec = VLC_CODEC_ALAW; p_sys->fmt.audio.i_bitspersample = 8; p_sys->fmt.audio.i_blockalign = 1 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_MULAW_8: /* 8-bit ISDN u-law */ p_sys->fmt.i_codec = VLC_CODEC_MULAW; p_sys->fmt.audio.i_bitspersample = 8; p_sys->fmt.audio.i_blockalign = 1 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_LINEAR_8: /* 8-bit linear PCM */ p_sys->fmt.i_codec = VLC_FOURCC( 't','w','o','s' ); p_sys->fmt.audio.i_bitspersample = 8; p_sys->fmt.audio.i_blockalign = 1 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_LINEAR_16: /* 16-bit linear PCM */ p_sys->fmt.i_codec = VLC_FOURCC( 't','w','o','s' ); p_sys->fmt.audio.i_bitspersample = 16; p_sys->fmt.audio.i_blockalign = 2 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_LINEAR_24: /* 24-bit linear PCM */ p_sys->fmt.i_codec = VLC_FOURCC( 't','w','o','s' ); p_sys->fmt.audio.i_bitspersample = 24; p_sys->fmt.audio.i_blockalign = 3 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_LINEAR_32: /* 32-bit linear PCM */ p_sys->fmt.i_codec = VLC_FOURCC( 't','w','o','s' ); p_sys->fmt.audio.i_bitspersample = 32; p_sys->fmt.audio.i_blockalign = 4 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_FLOAT: /* 32-bit IEEE floating point */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_FLOAT ); p_sys->fmt.audio.i_bitspersample = 32; p_sys->fmt.audio.i_blockalign = 4 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_DOUBLE: /* 64-bit IEEE floating point */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_DOUBLE ); p_sys->fmt.audio.i_bitspersample = 64; p_sys->fmt.audio.i_blockalign = 8 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_PCM; break; case AU_ADPCM_G721: /* 4-bit CCITT g.721 ADPCM */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_ADPCM_G721 ); p_sys->fmt.audio.i_bitspersample = 0; p_sys->fmt.audio.i_blockalign = 0 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_ADPCM; break; case AU_ADPCM_G722: /* CCITT g.722 ADPCM */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_ADPCM_G722 ); p_sys->fmt.audio.i_bitspersample = 0; p_sys->fmt.audio.i_blockalign = 0 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_ADPCM; break; case AU_ADPCM_G723_3: /* CCITT g.723 3-bit ADPCM */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_ADPCM_G723_3 ); p_sys->fmt.audio.i_bitspersample = 0; p_sys->fmt.audio.i_blockalign = 0 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_ADPCM; break; case AU_ADPCM_G723_5: /* CCITT g.723 5-bit ADPCM */ p_sys->fmt.i_codec = VLC_FOURCC( 'a', 'u', 0, AU_ADPCM_G723_5 ); p_sys->fmt.audio.i_bitspersample = 0; p_sys->fmt.audio.i_blockalign = 0 * p_sys->fmt.audio.i_channels; i_cat = AU_CAT_ADPCM; break; default: msg_Warn( p_demux, "unknow encoding=0x%x", GetDWBE( &hdr[8] ) ); p_sys->fmt.audio.i_bitspersample = 0; p_sys->fmt.audio.i_blockalign = 0; i_cat = AU_CAT_UNKNOWN; break; } p_sys->fmt.i_bitrate = p_sys->fmt.audio.i_rate * p_sys->fmt.audio.i_channels * p_sys->fmt.audio.i_bitspersample; if( i_cat == AU_CAT_UNKNOWN || i_cat == AU_CAT_ADPCM ) { p_sys->i_frame_size = 0; p_sys->i_frame_length = 0; msg_Err( p_demux, "unsupported codec/type (Please report it)" ); free( p_sys ); return VLC_EGENERIC; } if( p_sys->fmt.audio.i_rate == 0 ) { msg_Err( p_demux, "invalid samplerate: 0" ); free( p_sys ); return VLC_EGENERIC; } /* add the es */ p_sys->es = es_out_Add( p_demux->out, &p_sys->fmt ); /* calculate 50ms frame size/time */ i_samples = __MAX( p_sys->fmt.audio.i_rate / 20, 1 ); p_sys->i_frame_size = i_samples * p_sys->fmt.audio.i_channels * ( (p_sys->fmt.audio.i_bitspersample + 7) / 8 ); if( p_sys->fmt.audio.i_blockalign > 0 ) { if( ( i_modulo = p_sys->i_frame_size % p_sys->fmt.audio.i_blockalign ) != 0 ) { p_sys->i_frame_size += p_sys->fmt.audio.i_blockalign - i_modulo; } } p_sys->i_frame_length = (mtime_t)1000000 * (mtime_t)i_samples / (mtime_t)p_sys->fmt.audio.i_rate; return VLC_SUCCESS; }