/*****************************************************************************
* cdda.c : CD digital audio input module for vlc
*****************************************************************************
- * Copyright (C) 2000 VideoLAN
- * $Id: cdda.c,v 1.4 2003/05/22 12:00:56 gbazin Exp $
+ * Copyright (C) 2000, 2003 VideoLAN
+ * $Id: cdda.c,v 1.13 2004/02/05 22:56:12 gbazin Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
* Gildas Bazin <gbazin@netcourrier.com>
/*****************************************************************************
* Preamble
*****************************************************************************/
-#include <stdio.h>
#include <stdlib.h>
#include <vlc/vlc.h>
#include <vlc/input.h>
-#include <sys/types.h>
-#include "codecs.h"
+#include "vcd/cdrom.h"
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif
+typedef struct WAVEHEADER
+{
+ uint32_t MainChunkID; // it will be 'RIFF'
+ uint32_t Length;
+ uint32_t ChunkTypeID; // it will be 'WAVE'
+ uint32_t SubChunkID; // it will be 'fmt '
+ uint32_t SubChunkLength;
+ uint16_t Format;
+ uint16_t Modus;
+ uint32_t SampleFreq;
+ uint32_t BytesPerSec;
+ uint16_t BytesPerSample;
+ uint16_t BitsPerSample;
+ uint32_t DataChunkID; // it will be 'data'
+ uint32_t DataLength;
+} WAVEHEADER;
-#include <string.h>
+/*****************************************************************************
+ * Module descriptior
+ *****************************************************************************/
+static int AccessOpen ( vlc_object_t * );
+static void AccessClose( vlc_object_t * );
+
+#define CACHING_TEXT N_("Caching value in ms")
+#define CACHING_LONGTEXT N_( \
+ "Allows you to modify the default caching value for cdda streams. This " \
+ "value should be set in milliseconds units." )
+
+vlc_module_begin();
+ set_description( _("Audio CD input") );
+
+ add_integer( "cdda-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT,
+ CACHING_LONGTEXT, VLC_TRUE );
+
+ set_capability( "access", 70 );
+ set_callbacks( AccessOpen, AccessClose );
+ add_shortcut( "cdda" );
+vlc_module_end();
-#include "vcd/cdrom.h"
/* how many blocks VCDRead will read in each loop */
#define CDDA_BLOCKS_ONCE 20
#define CDDA_DATA_ONCE (CDDA_BLOCKS_ONCE * CDDA_DATA_SIZE)
/*****************************************************************************
- * cdda_data_t: CD audio information
+ * Access: local prototypes
*****************************************************************************/
-typedef struct cdda_data_s
+struct access_sys_t
{
vcddev_t *vcddev; /* vcd device descriptor */
int i_nb_tracks; /* Nb of tracks (titles) */
int * p_sectors; /* Track sectors */
vlc_bool_t b_end_of_track; /* If the end of track was reached */
-} cdda_data_t;
-
-struct demux_sys_t
-{
- es_descriptor_t *p_es;
- mtime_t i_pts;
+ WAVEHEADER waveheader; /* Wave header for the output data */
+ int i_header_pos;
};
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-static int CDDAOpen ( vlc_object_t * );
-static void CDDAClose ( vlc_object_t * );
-static int CDDARead ( input_thread_t *, byte_t *, size_t );
-static void CDDASeek ( input_thread_t *, off_t );
-static int CDDASetArea ( input_thread_t *, input_area_t * );
-static int CDDASetProgram ( input_thread_t *, pgrm_descriptor_t * );
-
-static int CDDAOpenDemux ( vlc_object_t * );
-static void CDDACloseDemux ( vlc_object_t * );
-static int CDDADemux ( input_thread_t * p_input );
+static int Read ( input_thread_t *, byte_t *, size_t );
+static void Seek ( input_thread_t *, off_t );
+static int SetArea ( input_thread_t *, input_area_t * );
+static int SetProgram( input_thread_t *, pgrm_descriptor_t * );
/*****************************************************************************
- * Module descriptior
+ * AccessOpen: open cdda
*****************************************************************************/
-#define CACHING_TEXT N_("Caching value in ms")
-#define CACHING_LONGTEXT N_( \
- "Allows you to modify the default caching value for cdda streams. This " \
- "value should be set in miliseconds units." )
-
-vlc_module_begin();
- set_description( _("CD Audio input") );
- add_integer( "cdda-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
- set_capability( "access", 70 );
- set_callbacks( CDDAOpen, CDDAClose );
- add_shortcut( "cdda" );
-
- add_submodule();
- set_description( _("CD Audio demux") );
- set_capability( "demux", 0 );
- set_callbacks( CDDAOpenDemux, CDDACloseDemux );
- add_shortcut( "cdda" );
-vlc_module_end();
-
-/*****************************************************************************
- * CDDAOpen: open cdda
- *****************************************************************************/
-static int CDDAOpen( vlc_object_t *p_this )
+static int AccessOpen( vlc_object_t *p_this )
{
input_thread_t * p_input = (input_thread_t *)p_this;
+ access_sys_t * p_sys;
+
char * psz_orig;
char * psz_parser;
char * psz_source;
- cdda_data_t * p_cdda;
int i;
input_area_t * p_area;
int i_title = 1;
if( !*psz_source )
{
+ /* No source specified, so figure it out. */
if( !p_input->psz_access )
{
free( psz_orig );
- return -1;
+ return VLC_EGENERIC;
}
- psz_source = config_GetPsz( p_input, "vcd" );
+ psz_source = config_GetPsz( p_input, "cd-audio" );
if( !psz_source ) return -1;
}
{
msg_Warn( p_input, "could not open %s", psz_source );
free( psz_source );
- return -1;
+ return VLC_EGENERIC;
}
free( psz_source );
- p_cdda = malloc( sizeof(cdda_data_t) );
- if( p_cdda == NULL )
+ p_input->p_access_data = p_sys = malloc( sizeof(access_sys_t) );
+ if( p_sys == NULL )
{
msg_Err( p_input, "out of memory" );
free( psz_source );
- return -1;
+ return VLC_EGENERIC;
}
- p_cdda->vcddev = vcddev;
- p_input->p_access_data = (void *)p_cdda;
+ p_sys->vcddev = vcddev;
p_input->i_mtu = CDDA_DATA_ONCE;
/* We read the Table Of Content information */
- p_cdda->i_nb_tracks = ioctl_GetTracksMap( VLC_OBJECT(p_input),
- p_cdda->vcddev, &p_cdda->p_sectors );
- if( p_cdda->i_nb_tracks < 0 )
+ p_sys->i_nb_tracks = ioctl_GetTracksMap( VLC_OBJECT(p_input),
+ p_sys->vcddev, &p_sys->p_sectors );
+ if( p_sys->i_nb_tracks < 0 )
+ {
msg_Err( p_input, "unable to count tracks" );
- else if( p_cdda->i_nb_tracks <= 0 )
+ }
+ else if( p_sys->i_nb_tracks <= 0 )
+ {
msg_Err( p_input, "no audio tracks found" );
+ }
- if( p_cdda->i_nb_tracks <= 1)
+ if( p_sys->i_nb_tracks <= 0 )
{
- ioctl_Close( p_this, p_cdda->vcddev );
- free( p_cdda );
- return -1;
+ ioctl_Close( p_this, p_sys->vcddev );
+ free( p_sys );
+ return VLC_EGENERIC;
}
- if( i_title >= p_cdda->i_nb_tracks || i_title < 1 )
+ if( i_title >= p_sys->i_nb_tracks || i_title < 1 )
+ {
i_title = 1;
+ }
/* Set stream and area data */
vlc_mutex_lock( &p_input->stream.stream_lock );
p_input->stream.i_mux_rate = 44100 * 4 / 50;
#define area p_input->stream.pp_areas
- for( i = 1 ; i <= p_cdda->i_nb_tracks ; i++ )
+ for( i = 1 ; i <= p_sys->i_nb_tracks ; i++ )
{
input_AddArea( p_input, i, 1 );
/* Absolute start offset and size */
area[i]->i_start =
- (off_t)p_cdda->p_sectors[i-1] * (off_t)CDDA_DATA_SIZE;
+ (off_t)p_sys->p_sectors[i-1] * (off_t)CDDA_DATA_SIZE;
area[i]->i_size =
- (off_t)(p_cdda->p_sectors[i] - p_cdda->p_sectors[i-1])
+ (off_t)(p_sys->p_sectors[i] - p_sys->p_sectors[i-1])
* (off_t)CDDA_DATA_SIZE;
}
#undef area
p_area = p_input->stream.pp_areas[i_title];
- CDDASetArea( p_input, p_area );
+ SetArea( p_input, p_area );
vlc_mutex_unlock( &p_input->stream.stream_lock );
- if( !p_input->psz_demux || !*p_input->psz_demux )
- {
- p_input->psz_demux = "cdda";
- }
-
- p_input->pf_read = CDDARead;
- p_input->pf_seek = CDDASeek;
- p_input->pf_set_area = CDDASetArea;
- p_input->pf_set_program = CDDASetProgram;
+ p_input->pf_read = Read;
+ p_input->pf_seek = Seek;
+ p_input->pf_set_area = SetArea;
+ p_input->pf_set_program = SetProgram;
/* Update default_pts to a suitable value for cdda access */
p_input->i_pts_delay = config_GetInt( p_input, "cdda-caching" ) * 1000;
- return 0;
+ /* Build a WAV header for the output data */
+ memset( &p_sys->waveheader, 0, sizeof(WAVEHEADER) );
+ p_sys->waveheader.Format = 1 /*WAVE_FORMAT_PCM*/;
+ p_sys->waveheader.BitsPerSample = 16;
+ p_sys->waveheader.MainChunkID = VLC_FOURCC('R', 'I', 'F', 'F');
+ p_sys->waveheader.Length = 0; /* we just don't know */
+ p_sys->waveheader.ChunkTypeID = VLC_FOURCC('W', 'A', 'V', 'E');
+ p_sys->waveheader.SubChunkID = VLC_FOURCC('f', 'm', 't', ' ');
+ p_sys->waveheader.SubChunkLength = 16;
+ p_sys->waveheader.Modus = 2;
+ p_sys->waveheader.SampleFreq = 44100;
+ p_sys->waveheader.BytesPerSample =
+ p_sys->waveheader.Modus * p_sys->waveheader.BitsPerSample / 8;
+ p_sys->waveheader.BytesPerSec =
+ p_sys->waveheader.BytesPerSample * p_sys->waveheader.SampleFreq;
+ p_sys->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a');
+ p_sys->waveheader.DataLength = 0; /* we just don't know */
+ p_sys->i_header_pos = 0;
+
+ return VLC_SUCCESS;
}
/*****************************************************************************
- * CDDAClose: closes cdda
+ * AccessClose: closes cdda
*****************************************************************************/
-static void CDDAClose( vlc_object_t *p_this )
+static void AccessClose( vlc_object_t *p_this )
{
- input_thread_t * p_input = (input_thread_t *)p_this;
- cdda_data_t *p_cdda = (cdda_data_t *)p_input->p_access_data;
+ input_thread_t *p_input = (input_thread_t *)p_this;
+ access_sys_t *p_sys = p_input->p_access_data;
- ioctl_Close( p_this, p_cdda->vcddev );
- free( p_cdda );
+ ioctl_Close( p_this, p_sys->vcddev );
+ free( p_sys );
}
/*****************************************************************************
- * CDDARead: reads from the CDDA into PES packets.
+ * Read: reads from the CDDA into PES packets.
*****************************************************************************
* Returns -1 in case of error, 0 in case of EOF, otherwise the number of
* bytes.
*****************************************************************************/
-static int CDDARead( input_thread_t * p_input, byte_t * p_buffer,
- size_t i_len )
+static int Read( input_thread_t * p_input, byte_t * p_buffer, size_t i_len )
{
- cdda_data_t * p_cdda;
- int i_blocks;
- int i_index;
- int i_read;
-
- p_cdda = (cdda_data_t *)p_input->p_access_data;
+ access_sys_t *p_sys = p_input->p_access_data;
+ int i_blocks = i_len / CDDA_DATA_SIZE;
+ int i_read = 0;
+ int i_index;
- i_read = 0;
-
- /* Compute the number of blocks we have to read */
-
- i_blocks = i_len / CDDA_DATA_SIZE;
+ if( !p_sys->i_header_pos )
+ {
+ p_sys->i_header_pos = sizeof(WAVEHEADER);
+ i_blocks = (i_len - sizeof(WAVEHEADER)) / CDDA_DATA_SIZE;
+ memcpy( p_buffer, &p_sys->waveheader, sizeof(WAVEHEADER) );
+ p_buffer += sizeof(WAVEHEADER);
+ }
- if ( ioctl_ReadSectors( VLC_OBJECT(p_input), p_cdda->vcddev,
- p_cdda->i_sector, p_buffer, i_blocks, CDDA_TYPE ) < 0 )
+ if( ioctl_ReadSectors( VLC_OBJECT(p_input), p_sys->vcddev, p_sys->i_sector,
+ p_buffer, i_blocks, CDDA_TYPE ) < 0 )
{
- msg_Err( p_input, "could not read sector %d", p_cdda->i_sector );
+ msg_Err( p_input, "could not read sector %d", p_sys->i_sector );
return -1;
}
- for ( i_index = 0; i_index < i_blocks; i_index++ )
+ for( i_index = 0; i_index < i_blocks; i_index++ )
{
- p_cdda->i_sector ++;
- if ( p_cdda->i_sector == p_cdda->p_sectors[p_cdda->i_track + 1] )
+ p_sys->i_sector ++;
+ if( p_sys->i_sector == p_sys->p_sectors[p_sys->i_track + 1] )
{
input_area_t *p_area;
- if ( p_cdda->i_track >= p_cdda->i_nb_tracks - 1 )
+ if ( p_sys->i_track >= p_sys->i_nb_tracks - 1 )
+ {
return 0; /* EOF */
+ }
vlc_mutex_lock( &p_input->stream.stream_lock );
p_area = p_input->stream.pp_areas[
msg_Dbg( p_input, "new title" );
p_area->i_part = 1;
- CDDASetArea( p_input, p_area );
+ SetArea( p_input, p_area );
vlc_mutex_unlock( &p_input->stream.stream_lock );
}
i_read += CDDA_DATA_SIZE;
return i_read;
}
-
/*****************************************************************************
- * CDDASetProgram: Does nothing since a CDDA is mono_program
+ * SetProgram: Does nothing since a CDDA is mono_program
*****************************************************************************/
-static int CDDASetProgram( input_thread_t * p_input,
+static int SetProgram( input_thread_t * p_input,
pgrm_descriptor_t * p_program)
{
- return 0;
+ return VLC_EGENERIC;
}
-
/*****************************************************************************
- * CDDASetArea: initialize input data for title x.
+ * SetArea: initialize input data for title x.
* It should be called for each user navigation request.
****************************************************************************/
-static int CDDASetArea( input_thread_t * p_input, input_area_t * p_area )
+static int SetArea( input_thread_t * p_input, input_area_t * p_area )
{
- cdda_data_t *p_cdda = (cdda_data_t*)p_input->p_access_data;
- vlc_value_t val;
+ access_sys_t *p_sys = p_input->p_access_data;
+ vlc_value_t val;
/* we can't use the interface slider until initilization is complete */
p_input->stream.b_seekable = 0;
p_input->stream.p_selected_area = p_area;
/* Change the current track */
- p_cdda->i_track = p_area->i_id - 1;
- p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track];
+ p_sys->i_track = p_area->i_id - 1;
+ p_sys->i_sector = p_sys->p_sectors[p_sys->i_track];
/* Update the navigation variables without triggering a callback */
val.i_int = p_area->i_id;
var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
}
- p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track];
+ p_sys->i_sector = p_sys->p_sectors[p_sys->i_track];
p_input->stream.p_selected_area->i_tell =
- (off_t)p_cdda->i_sector * (off_t)CDDA_DATA_SIZE
+ (off_t)p_sys->i_sector * (off_t)CDDA_DATA_SIZE
- p_input->stream.p_selected_area->i_start;
/* warn interface that something has changed */
return 0;
}
-
/****************************************************************************
- * CDDASeek
+ * Seek
****************************************************************************/
-static void CDDASeek( input_thread_t * p_input, off_t i_off )
+static void Seek( input_thread_t * p_input, off_t i_off )
{
- cdda_data_t * p_cdda;
-
- p_cdda = (cdda_data_t *) p_input->p_access_data;
+ access_sys_t * p_sys = p_input->p_access_data;
- p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track]
+ p_sys->i_sector = p_sys->p_sectors[p_sys->i_track]
+ i_off / (off_t)CDDA_DATA_SIZE;
vlc_mutex_lock( &p_input->stream.stream_lock );
p_input->stream.p_selected_area->i_tell =
- (off_t)p_cdda->i_sector * (off_t)CDDA_DATA_SIZE
+ (off_t)p_sys->i_sector * (off_t)CDDA_DATA_SIZE
- p_input->stream.p_selected_area->i_start;
vlc_mutex_unlock( &p_input->stream.stream_lock );
}
-
-/****************************************************************************
- * Demux Part
- ****************************************************************************/
-static int CDDAOpenDemux ( vlc_object_t * p_this)
-{
- input_thread_t *p_input = (input_thread_t *)p_this;
- demux_sys_t *p_demux;
- WAVEFORMATEX *p_wf;
-
- if( p_input->stream.i_method != INPUT_METHOD_CDDA )
- {
- return VLC_EGENERIC;
- }
-
- p_demux = malloc( sizeof( es_descriptor_t ) );
- p_demux->i_pts = 0;
- p_demux->p_es = NULL;
-
- p_input->pf_demux = CDDADemux;
- p_input->pf_rewind = NULL;
- p_input->p_demux_data = p_demux;
-
- vlc_mutex_lock( &p_input->stream.stream_lock );
- if( input_AddProgram( p_input, 0, 0) == NULL )
- {
- msg_Err( p_input, "cannot add program" );
- free( p_input->p_demux_data );
- return( -1 );
- }
- p_input->stream.pp_programs[0]->b_is_ok = 0;
- p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
-
- /* create our ES */
- p_demux->p_es = input_AddES( p_input,
- p_input->stream.p_selected_program,
- 1 /* id */, AUDIO_ES, NULL, 0 );
- if( !p_demux->p_es )
- {
- vlc_mutex_unlock( &p_input->stream.stream_lock );
- msg_Err( p_input, "out of memory" );
- free( p_input->p_demux_data );
- return( -1 );
- }
- p_demux->p_es->i_stream_id = 1;
- p_demux->p_es->i_fourcc = VLC_FOURCC('a','r','a','w');
-
- p_demux->p_es->p_waveformatex = p_wf = malloc( sizeof( WAVEFORMATEX ) );
- p_wf->wFormatTag = WAVE_FORMAT_PCM;
- p_wf->nChannels = 2;
- p_wf->nSamplesPerSec = 44100;
- p_wf->nAvgBytesPerSec = 2 * 44100 * 2;
- p_wf->nBlockAlign = 4;
- p_wf->wBitsPerSample = 16;
- p_wf->cbSize = 0;
-
- input_SelectES( p_input, p_demux->p_es );
-
- p_input->stream.p_selected_program->b_is_ok = 1;
- vlc_mutex_unlock( &p_input->stream.stream_lock );
-
- return VLC_SUCCESS;
-}
-
-static void CDDACloseDemux( vlc_object_t * p_this)
-{
- input_thread_t *p_input = (input_thread_t*)p_this;
- demux_sys_t *p_demux = (demux_sys_t*)p_input->p_demux_data;
-
- free( p_demux );
- p_input->p_demux_data = NULL;
- return;
-}
-
-static int CDDADemux( input_thread_t * p_input )
-{
- demux_sys_t *p_demux = (demux_sys_t*)p_input->p_demux_data;
- ssize_t i_read;
- data_packet_t * p_data;
- pes_packet_t * p_pes;
-
- input_ClockManageRef( p_input,
- p_input->stream.p_selected_program,
- p_demux->i_pts );
-
- if( ( i_read = input_SplitBuffer( p_input, &p_data, CDDA_DATA_SIZE ) )
- <= 0 )
- {
- return 0; // EOF
- }
-
- p_pes = input_NewPES( p_input->p_method_data );
-
- if( p_pes == NULL )
- {
- msg_Err( p_input, "out of memory" );
- input_DeletePacket( p_input->p_method_data, p_data );
- return -1;
- }
-
- p_pes->i_rate = p_input->stream.control.i_rate;
- p_pes->p_first = p_pes->p_last = p_data;
- p_pes->i_nb_data = 1;
- p_pes->i_pes_size = i_read;
-
- p_pes->i_dts =
- p_pes->i_pts = input_ClockGetTS( p_input,
- p_input->stream.p_selected_program,
- p_demux->i_pts );
-
- if( p_demux->p_es->p_decoder_fifo )
- {
- input_DecodePES( p_demux->p_es->p_decoder_fifo, p_pes );
- }
- else
- {
- input_DeletePES( p_input->p_method_data, p_pes );
- }
-
- p_demux->i_pts += ((mtime_t)90000) * i_read
- / (mtime_t)44100 / 4 /* stereo 16 bits */;
- return 1;
-}
projects / vlc / blobdiff