1 /*****************************************************************************
2 * raop.c: Remote Audio Output Protocol streaming support
3 *****************************************************************************
4 * Copyright (C) 2008 the VideoLAN team
7 * Author: Michael Hanselmann
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
38 #include <vlc_block.h>
39 #include <vlc_network.h>
40 #include <vlc_strings.h>
41 #include <vlc_charset.h>
43 #include <vlc_gcrypt.h>
46 #include <vlc_memory.h>
48 #define RAOP_PORT 5000
49 #define RAOP_USER_AGENT "VLC " VERSION
52 static const char ps_raop_rsa_pubkey
[] =
53 "\xe7\xd7\x44\xf2\xa2\xe2\x78\x8b\x6c\x1f\x55\xa0\x8e\xb7\x05\x44"
54 "\xa8\xfa\x79\x45\xaa\x8b\xe6\xc6\x2c\xe5\xf5\x1c\xbd\xd4\xdc\x68"
55 "\x42\xfe\x3d\x10\x83\xdd\x2e\xde\xc1\xbf\xd4\x25\x2d\xc0\x2e\x6f"
56 "\x39\x8b\xdf\x0e\x61\x48\xea\x84\x85\x5e\x2e\x44\x2d\xa6\xd6\x26"
57 "\x64\xf6\x74\xa1\xf3\x04\x92\x9a\xde\x4f\x68\x93\xef\x2d\xf6\xe7"
58 "\x11\xa8\xc7\x7a\x0d\x91\xc9\xd9\x80\x82\x2e\x50\xd1\x29\x22\xaf"
59 "\xea\x40\xea\x9f\x0e\x14\xc0\xf7\x69\x38\xc5\xf3\x88\x2f\xc0\x32"
60 "\x3d\xd9\xfe\x55\x15\x5f\x51\xbb\x59\x21\xc2\x01\x62\x9f\xd7\x33"
61 "\x52\xd5\xe2\xef\xaa\xbf\x9b\xa0\x48\xd7\xb8\x13\xa2\xb6\x76\x7f"
62 "\x6c\x3c\xcf\x1e\xb4\xce\x67\x3d\x03\x7b\x0d\x2e\xa3\x0c\x5f\xff"
63 "\xeb\x06\xf8\xd0\x8a\xdd\xe4\x09\x57\x1a\x9c\x68\x9f\xef\x10\x72"
64 "\x88\x55\xdd\x8c\xfb\x9a\x8b\xef\x5c\x89\x43\xef\x3b\x5f\xaa\x15"
65 "\xdd\xe6\x98\xbe\xdd\xf3\x59\x96\x03\xeb\x3e\x6f\x61\x37\x2b\xb6"
66 "\x28\xf6\x55\x9f\x59\x9a\x78\xbf\x50\x06\x87\xaa\x7f\x49\x76\xc0"
67 "\x56\x2d\x41\x29\x56\xf8\x98\x9e\x18\xa6\x35\x5b\xd8\x15\x97\x82"
68 "\x5e\x0f\xc8\x75\x34\x3e\xc7\x82\x11\x76\x25\xcd\xbf\x98\x44\x7b";
70 static const char ps_raop_rsa_exp
[] = "\x01\x00\x01";
72 static const char psz_delim_space
[] = " ";
73 static const char psz_delim_colon
[] = ":";
74 static const char psz_delim_equal
[] = "=";
75 static const char psz_delim_semicolon
[] = ";";
78 /*****************************************************************************
80 *****************************************************************************/
81 static int Open( vlc_object_t
* );
82 static void Close( vlc_object_t
* );
84 static sout_stream_id_t
*Add( sout_stream_t
*, es_format_t
* );
85 static int Del( sout_stream_t
*, sout_stream_id_t
* );
86 static int Send( sout_stream_t
*, sout_stream_id_t
*, block_t
* );
88 static int VolumeCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
89 vlc_value_t oldval
, vlc_value_t newval
,
99 struct sout_stream_sys_t
101 /* Input parameters */
107 sout_stream_id_t
*p_audio_stream
;
109 bool b_volume_callback
;
111 /* Connection state */
115 uint8_t ps_aes_key
[16];
116 uint8_t ps_aes_iv
[16];
117 gcry_cipher_hd_t aes_ctx
;
120 char *psz_client_instance
;
122 char *psz_last_status_line
;
132 size_t i_sendbuf_len
;
136 struct sout_stream_id_t
142 /*****************************************************************************
144 *****************************************************************************/
145 #define SOUT_CFG_PREFIX "sout-raop-"
147 #define HOST_TEXT N_("Host")
148 #define HOST_LONGTEXT N_("Hostname or IP address of target device")
150 #define VOLUME_TEXT N_("Volume")
151 #define VOLUME_LONGTEXT N_("Output volume for analog output: 0 for silence, " \
152 "1..255 from almost silent to very loud.")
154 #define PASSWORD_TEXT N_("Password")
155 #define PASSWORD_LONGTEXT N_("Password for target device.")
157 #define PASSWORD_FILE_TEXT N_("Password file")
158 #define PASSWORD_FILE_LONGTEXT N_("Read password for target device from file.")
161 set_shortname( N_("RAOP") )
162 set_description( N_("Remote Audio Output Protocol stream output") )
163 set_capability( "sout stream", 0 )
164 add_shortcut( "raop" )
165 set_category( CAT_SOUT
)
166 set_subcategory( SUBCAT_SOUT_STREAM
)
167 add_string( SOUT_CFG_PREFIX
"host", "",
168 HOST_TEXT
, HOST_LONGTEXT
, false )
169 add_password( SOUT_CFG_PREFIX
"password", NULL
, NULL
,
170 PASSWORD_TEXT
, PASSWORD_LONGTEXT
, false )
171 add_loadfile( SOUT_CFG_PREFIX
"password-file", NULL
, NULL
,
172 PASSWORD_FILE_TEXT
, PASSWORD_FILE_LONGTEXT
, false )
173 add_integer_with_range( SOUT_CFG_PREFIX
"volume", 100, 0, 255, NULL
,
174 VOLUME_TEXT
, VOLUME_LONGTEXT
, false )
175 set_callbacks( Open
, Close
)
178 static const char *const ppsz_sout_options
[] = {
187 /*****************************************************************************
189 *****************************************************************************/
190 static void FreeSys( vlc_object_t
*p_this
, sout_stream_sys_t
*p_sys
)
192 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
194 if ( p_sys
->i_control_fd
>= 0 )
195 net_Close( p_sys
->i_control_fd
);
196 if ( p_sys
->i_stream_fd
>= 0 )
197 net_Close( p_sys
->i_stream_fd
);
198 if ( p_sys
->b_volume_callback
)
199 var_DelCallback( p_stream
, SOUT_CFG_PREFIX
"volume",
200 VolumeCallback
, NULL
);
202 gcry_cipher_close( p_sys
->aes_ctx
);
204 free( p_sys
->p_sendbuf
);
205 free( p_sys
->psz_host
);
206 free( p_sys
->psz_password
);
207 free( p_sys
->psz_url
);
208 free( p_sys
->psz_session
);
209 free( p_sys
->psz_client_instance
);
210 free( p_sys
->psz_last_status_line
);
214 static void FreeId( sout_stream_id_t
*id
)
219 static void RemoveBase64Padding( char *str
)
221 char *ps_pos
= strchr( str
, '=' );
222 if ( ps_pos
!= NULL
)
226 static int CheckForGcryptErrorWithLine( sout_stream_t
*p_stream
,
227 gcry_error_t i_gcrypt_err
,
228 unsigned int i_line
)
230 if ( i_gcrypt_err
!= GPG_ERR_NO_ERROR
)
232 msg_Err( p_stream
, "gcrypt error (line %d): %s", i_line
,
233 gpg_strerror( i_gcrypt_err
) );
240 /* Wrapper to pass line number for easier debugging */
241 #define CheckForGcryptError( p_this, i_gcrypt_err ) \
242 CheckForGcryptErrorWithLine( p_this, i_gcrypt_err, __LINE__ )
244 /* MGF1 is specified in RFC2437, section 10.2.1. Variables are named after the
247 static int MGF1( vlc_object_t
*p_this
,
248 unsigned char *mask
, size_t l
,
249 const unsigned char *Z
, const size_t zLen
,
252 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
253 gcry_error_t i_gcrypt_err
;
254 gcry_md_hd_t md_handle
= NULL
;
256 unsigned char *ps_md
;
257 uint32_t counter
= 0;
260 int i_err
= VLC_SUCCESS
;
262 assert( mask
!= NULL
);
265 hLen
= gcry_md_get_algo_dlen( Hash
);
267 i_gcrypt_err
= gcry_md_open( &md_handle
, Hash
, 0 );
268 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
270 i_err
= VLC_EGENERIC
;
276 /* 3. For counter from 0 to \lceil{l / hLen}\rceil-1, do the following:
277 * a. Convert counter to an octet string C of length 4 with the
278 * primitive I2OSP: C = I2OSP (counter, 4)
280 C
[0] = (counter
>> 24) & 0xff;
281 C
[1] = (counter
>> 16) & 0xff;
282 C
[2] = (counter
>> 8) & 0xff;
283 C
[3] = counter
& 0xff;
286 /* b. Concatenate the hash of the seed Z and C to the octet string T:
287 * T = T || Hash (Z || C)
289 gcry_md_reset( md_handle
);
290 gcry_md_write( md_handle
, Z
, zLen
);
291 gcry_md_write( md_handle
, C
, 4 );
292 ps_md
= gcry_md_read( md_handle
, Hash
);
294 /* 4. Output the leading l octets of T as the octet string mask. */
295 i_copylen
= __MIN( l
, hLen
);
296 memcpy( mask
, ps_md
, i_copylen
);
302 gcry_md_close( md_handle
);
307 /* EME-OAEP-ENCODE is specified in RFC2437, section 9.1.1.1. Variables are
308 * named after the specification.
310 static int AddOaepPadding( vlc_object_t
*p_this
,
311 unsigned char *EM
, const size_t emLenWithPrefix
,
312 const unsigned char *M
, const size_t mLen
,
313 const unsigned char *P
, const size_t pLen
)
315 const int Hash
= GCRY_MD_SHA1
;
316 const unsigned int hLen
= gcry_md_get_algo_dlen( Hash
);
317 unsigned char *seed
= NULL
;
318 unsigned char *DB
= NULL
;
319 unsigned char *dbMask
= NULL
;
320 unsigned char *seedMask
= NULL
;
324 int i_err
= VLC_SUCCESS
;
326 /* Space for 0x00 prefix in EM. */
327 emLen
= emLenWithPrefix
- 1;
330 * If ||M|| > emLen-2hLen-1 then output "message too long" and stop.
332 if ( mLen
> (emLen
- (2 * hLen
) - 1) )
334 msg_Err( p_this
, "Message too long" );
339 * Generate an octet string PS consisting of emLen-||M||-2hLen-1 zero
340 * octets. The length of PS may be 0.
342 psLen
= emLen
- mLen
- (2 * hLen
) - 1;
346 * Concatenate pHash, PS, the message M, and other padding to form a data
347 * block DB as: DB = pHash || PS || 01 || M
349 DB
= calloc( 1, hLen
+ psLen
+ 1 + mLen
);
350 dbMask
= calloc( 1, emLen
- hLen
);
351 seedMask
= calloc( 1, hLen
);
353 if ( DB
== NULL
|| dbMask
== NULL
|| seedMask
== NULL
)
360 * Let pHash = Hash(P), an octet string of length hLen.
362 gcry_md_hash_buffer( Hash
, DB
, P
, pLen
);
365 * Generate an octet string PS consisting of emLen-||M||-2hLen-1 zero
366 * octets. The length of PS may be 0.
368 memset( DB
+ hLen
, 0, psLen
);
371 * Concatenate pHash, PS, the message M, and other padding to form a data
372 * block DB as: DB = pHash || PS || 01 || M
374 DB
[hLen
+ psLen
] = 0x01;
375 memcpy( DB
+ hLen
+ psLen
+ 1, M
, mLen
);
378 * Generate a random octet string seed of length hLen
380 seed
= gcry_random_bytes( hLen
, GCRY_STRONG_RANDOM
);
388 * Let dbMask = MGF(seed, emLen-hLen).
390 i_err
= MGF1( p_this
, dbMask
, emLen
- hLen
, seed
, hLen
, Hash
);
391 if ( i_err
!= VLC_SUCCESS
)
395 * Let maskedDB = DB \xor dbMask.
397 for ( i
= 0; i
< (emLen
- hLen
); ++i
)
401 * Let seedMask = MGF(maskedDB, hLen).
403 i_err
= MGF1( p_this
, seedMask
, hLen
, DB
, emLen
- hLen
, Hash
);
404 if ( i_err
!= VLC_SUCCESS
)
408 * Let maskedSeed = seed \xor seedMask.
410 for ( i
= 0; i
< hLen
; ++i
)
411 seed
[i
] ^= seedMask
[i
];
414 * Let EM = maskedSeed || maskedDB.
416 assert( (1 + hLen
+ (hLen
+ psLen
+ 1 + mLen
)) == emLenWithPrefix
);
418 memcpy( EM
+ 1, seed
, hLen
);
419 memcpy( EM
+ 1 + hLen
, DB
, hLen
+ psLen
+ 1 + mLen
);
434 static int EncryptAesKeyBase64( vlc_object_t
*p_this
, char **result
)
436 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
437 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
438 gcry_error_t i_gcrypt_err
;
439 gcry_sexp_t sexp_rsa_params
= NULL
;
440 gcry_sexp_t sexp_input
= NULL
;
441 gcry_sexp_t sexp_encrypted
= NULL
;
442 gcry_sexp_t sexp_token_a
= NULL
;
443 gcry_mpi_t mpi_pubkey
= NULL
;
444 gcry_mpi_t mpi_exp
= NULL
;
445 gcry_mpi_t mpi_input
= NULL
;
446 gcry_mpi_t mpi_output
= NULL
;
447 unsigned char ps_padded_key
[256];
448 unsigned char *ps_value
;
452 /* Add RSA-OAES-SHA1 padding */
453 i_err
= AddOaepPadding( p_this
,
454 ps_padded_key
, sizeof( ps_padded_key
),
455 p_sys
->ps_aes_key
, sizeof( p_sys
->ps_aes_key
),
457 if ( i_err
!= VLC_SUCCESS
)
459 i_err
= VLC_EGENERIC
;
461 /* Read public key */
462 i_gcrypt_err
= gcry_mpi_scan( &mpi_pubkey
, GCRYMPI_FMT_USG
,
464 sizeof( ps_raop_rsa_pubkey
) - 1, NULL
);
465 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
469 i_gcrypt_err
= gcry_mpi_scan( &mpi_exp
, GCRYMPI_FMT_USG
, ps_raop_rsa_exp
,
470 sizeof( ps_raop_rsa_exp
) - 1, NULL
);
471 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
474 /* If the input data starts with a set bit (0x80), gcrypt thinks it's a
475 * signed integer and complains. Prefixing it with a zero byte (\0)
476 * works, but involves more work. Converting it to an MPI in our code is
479 i_gcrypt_err
= gcry_mpi_scan( &mpi_input
, GCRYMPI_FMT_USG
,
480 ps_padded_key
, sizeof( ps_padded_key
),
482 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
485 /* Build S-expression with RSA parameters */
486 i_gcrypt_err
= gcry_sexp_build( &sexp_rsa_params
, NULL
,
487 "(public-key(rsa(n %m)(e %m)))",
488 mpi_pubkey
, mpi_exp
);
489 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
492 /* Build S-expression for data */
493 i_gcrypt_err
= gcry_sexp_build( &sexp_input
, NULL
, "(data(value %m))",
495 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
499 i_gcrypt_err
= gcry_pk_encrypt( &sexp_encrypted
, sexp_input
,
501 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
504 /* Extract encrypted data */
505 sexp_token_a
= gcry_sexp_find_token( sexp_encrypted
, "a", 0 );
508 msg_Err( p_this
, "Token 'a' not found in result S-expression" );
512 mpi_output
= gcry_sexp_nth_mpi( sexp_token_a
, 1, GCRYMPI_FMT_USG
);
515 msg_Err( p_this
, "Unable to extract MPI from result" );
519 /* Copy encrypted data into char array */
520 i_gcrypt_err
= gcry_mpi_aprint( GCRYMPI_FMT_USG
, &ps_value
, &i_value_size
,
522 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
527 /* Encode in Base64 */
528 *result
= vlc_b64_encode_binary( ps_value
, i_value_size
);
532 gcry_sexp_release( sexp_rsa_params
);
533 gcry_sexp_release( sexp_input
);
534 gcry_sexp_release( sexp_encrypted
);
535 gcry_sexp_release( sexp_token_a
);
536 gcry_mpi_release( mpi_pubkey
);
537 gcry_mpi_release( mpi_exp
);
538 gcry_mpi_release( mpi_input
);
539 gcry_mpi_release( mpi_output
);
544 static char *ReadPasswordFile( vlc_object_t
*p_this
, const char *psz_path
)
547 char *psz_password
= NULL
;
551 p_file
= vlc_fopen( psz_path
, "rt" );
552 if ( p_file
== NULL
)
554 msg_Err( p_this
, "Unable to open password file '%s': %m", psz_path
);
558 /* Read one line only */
559 if ( fgets( ps_buffer
, sizeof( ps_buffer
), p_file
) == NULL
)
561 if ( ferror( p_file
) )
563 msg_Err( p_this
, "Error reading '%s': %m", psz_path
);
567 /* Nothing was read, but there was no error either. Maybe the file is
568 * empty. Not all implementations of fgets(3) write \0 to the output
569 * buffer in this case.
574 /* Replace first newline with '\0' */
575 psz_newline
= strchr( ps_buffer
, '\n' );
576 if ( psz_newline
!= NULL
)
580 if ( *ps_buffer
== '\0' ) {
581 msg_Err( p_this
, "No password could be read from '%s'", psz_path
);
585 psz_password
= strdup( ps_buffer
);
588 if ( p_file
!= NULL
)
594 /* Splits the value of a received header.
596 * Example: "Transport: RTP/AVP/TCP;unicast;mode=record;server_port=6000"
598 static int SplitHeader( char **ppsz_next
, char **ppsz_name
,
601 /* Find semicolon (separator between assignments) */
602 *ppsz_name
= strsep( ppsz_next
, psz_delim_semicolon
);
606 *ppsz_name
+= strspn( *ppsz_name
, psz_delim_space
);
609 *ppsz_value
= *ppsz_name
;
610 strsep( ppsz_value
, psz_delim_equal
);
618 static void FreeHeader( void *p_value
, void *p_data
)
620 VLC_UNUSED( p_data
);
624 static int ReadStatusLine( vlc_object_t
*p_this
)
626 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
627 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
628 char *psz_line
= NULL
;
631 int i_result
= VLC_EGENERIC
;
633 p_sys
->psz_last_status_line
= net_Gets( p_this
, p_sys
->i_control_fd
,
635 if ( !p_sys
->psz_last_status_line
)
638 /* Create working copy */
639 psz_line
= strdup( p_sys
->psz_last_status_line
);
643 psz_token
= strsep( &psz_next
, psz_delim_space
);
644 if ( !psz_token
|| strncmp( psz_token
, "RTSP/1.", 7 ) != 0 )
646 msg_Err( p_this
, "Unknown protocol (%s)",
647 p_sys
->psz_last_status_line
);
652 psz_token
= strsep( &psz_next
, psz_delim_space
);
655 msg_Err( p_this
, "Request failed (%s)",
656 p_sys
->psz_last_status_line
);
660 i_result
= atoi( psz_token
);
668 static int ReadHeader( vlc_object_t
*p_this
,
669 vlc_dictionary_t
*p_resp_headers
,
672 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
673 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
674 char *psz_original
= NULL
;
675 char *psz_line
= NULL
;
680 int i_err
= VLC_SUCCESS
;
682 psz_line
= net_Gets( p_this
, p_sys
->i_control_fd
, NULL
);
685 i_err
= VLC_EGENERIC
;
689 /* Empty line for response end */
690 if ( psz_line
[0] == '\0' )
694 psz_original
= strdup( psz_line
);
697 psz_token
= strsep( &psz_next
, psz_delim_colon
);
698 if ( !psz_token
|| psz_next
[0] != ' ' )
700 msg_Err( p_this
, "Invalid header format (%s)", psz_original
);
701 i_err
= VLC_EGENERIC
;
705 psz_name
= psz_token
;
706 psz_value
= psz_next
+ 1;
708 vlc_dictionary_insert( p_resp_headers
, psz_name
, strdup( psz_value
) );
712 free( psz_original
);
718 static int WriteAuxHeaders( vlc_object_t
*p_this
,
719 vlc_dictionary_t
*p_req_headers
)
721 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
722 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
723 char **ppsz_keys
= NULL
;
726 int i_err
= VLC_SUCCESS
;
730 ppsz_keys
= vlc_dictionary_all_keys( p_req_headers
);
731 for ( i
= 0; ppsz_keys
[i
]; ++i
)
733 psz_key
= ppsz_keys
[i
];
734 psz_value
= vlc_dictionary_value_for_key( p_req_headers
, psz_key
);
736 i_rc
= net_Printf( p_this
, p_sys
->i_control_fd
, NULL
,
737 "%s: %s\r\n", psz_key
, psz_value
);
740 i_err
= VLC_EGENERIC
;
746 for ( i
= 0; ppsz_keys
[i
]; ++i
)
747 free( ppsz_keys
[i
] );
753 static int SendRequest( vlc_object_t
*p_this
, const char *psz_method
,
754 const char *psz_content_type
, const char *psz_body
,
755 vlc_dictionary_t
*p_req_headers
)
757 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
758 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
759 const unsigned char psz_headers_end
[] = "\r\n";
760 size_t i_body_length
= 0;
761 int i_err
= VLC_SUCCESS
;
764 i_rc
= net_Printf( p_this
, p_sys
->i_control_fd
, NULL
,
766 "User-Agent: " RAOP_USER_AGENT
"\r\n"
767 "Client-Instance: %s\r\n"
769 psz_method
, p_sys
->psz_url
,
770 p_sys
->psz_client_instance
,
774 i_err
= VLC_EGENERIC
;
778 if ( psz_content_type
)
780 i_rc
= net_Printf( p_this
, p_sys
->i_control_fd
, NULL
,
781 "Content-Type: %s\r\n", psz_content_type
);
791 i_body_length
= strlen( psz_body
);
793 i_rc
= net_Printf( p_this
, p_sys
->i_control_fd
, NULL
,
794 "Content-Length: %u\r\n",
795 (unsigned int)i_body_length
);
803 i_err
= WriteAuxHeaders( p_this
, p_req_headers
);
804 if ( i_err
!= VLC_SUCCESS
)
807 i_rc
= net_Write( p_this
, p_sys
->i_control_fd
, NULL
,
808 psz_headers_end
, sizeof( psz_headers_end
) - 1 );
816 net_Write( p_this
, p_sys
->i_control_fd
, NULL
,
817 psz_body
, i_body_length
);
823 static int ParseAuthenticateHeader( vlc_object_t
*p_this
,
824 vlc_dictionary_t
*p_resp_headers
)
826 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
827 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
829 int i_err
= VLC_SUCCESS
;
831 psz_auth
= vlc_dictionary_value_for_key( p_resp_headers
,
832 "WWW-Authenticate" );
833 if ( psz_auth
== NULL
)
835 msg_Err( p_this
, "HTTP 401 response missing "
836 "WWW-Authenticate header" );
837 i_err
= VLC_EGENERIC
;
841 http_auth_ParseWwwAuthenticateHeader( p_this
, &p_sys
->auth
, psz_auth
);
847 static int ExecRequest( vlc_object_t
*p_this
, const char *psz_method
,
848 const char *psz_content_type
, const char *psz_body
,
849 vlc_dictionary_t
*p_req_headers
,
850 vlc_dictionary_t
*p_resp_headers
)
852 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
853 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
854 char *psz_authorization
= NULL
;
856 int i_err
= VLC_SUCCESS
;
860 if ( p_sys
->i_control_fd
< 0 )
862 msg_Err( p_this
, "Control connection not open" );
863 i_err
= VLC_EGENERIC
;
870 /* Send header only when Digest authentication is used */
871 if ( p_sys
->psz_password
!= NULL
&& p_sys
->auth
.psz_nonce
!= NULL
)
873 FREENULL( psz_authorization
);
876 http_auth_FormatAuthorizationHeader( p_this
, &p_sys
->auth
,
879 p_sys
->psz_password
);
880 if ( psz_authorization
== NULL
)
882 i_err
= VLC_EGENERIC
;
886 vlc_dictionary_insert( p_req_headers
, "Authorization",
891 i_err
= SendRequest( p_this
, psz_method
, psz_content_type
, psz_body
,
893 if ( i_err
!= VLC_SUCCESS
)
896 /* Read status line */
897 i_status
= ReadStatusLine( p_this
);
904 vlc_dictionary_clear( p_resp_headers
, FreeHeader
, NULL
);
908 while ( !headers_done
)
910 i_err
= ReadHeader( p_this
, p_resp_headers
, &headers_done
);
911 if ( i_err
!= VLC_SUCCESS
)
915 if ( i_status
== 200 )
916 /* Request successful */
918 else if ( i_status
== 401 )
920 /* Authorization required */
921 if ( i_auth_state
== 1 || p_sys
->psz_password
== NULL
)
923 msg_Err( p_this
, "Access denied, password invalid" );
924 i_err
= VLC_EGENERIC
;
928 i_err
= ParseAuthenticateHeader( p_this
, p_resp_headers
);
929 if ( i_err
!= VLC_SUCCESS
)
936 msg_Err( p_this
, "Request failed (%s), status is %d",
937 p_sys
->psz_last_status_line
, i_status
);
938 i_err
= VLC_EGENERIC
;
944 FREENULL( p_sys
->psz_last_status_line
);
945 free( psz_authorization
);
950 static int AnnounceSDP( vlc_object_t
*p_this
, char *psz_local
,
951 uint32_t i_session_id
)
953 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
954 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
955 vlc_dictionary_t req_headers
;
956 vlc_dictionary_t resp_headers
;
957 unsigned char ps_sac
[16];
958 char *psz_sdp
= NULL
;
959 char *psz_sac_base64
= NULL
;
960 char *psz_aes_key_base64
= NULL
;
961 char *psz_aes_iv_base64
= NULL
;
962 int i_err
= VLC_SUCCESS
;
965 vlc_dictionary_init( &req_headers
, 0 );
966 vlc_dictionary_init( &resp_headers
, 0 );
968 /* Encrypt AES key and encode it in Base64 */
969 i_rc
= EncryptAesKeyBase64( p_this
, &psz_aes_key_base64
);
970 if ( i_rc
!= VLC_SUCCESS
|| psz_aes_key_base64
== NULL
)
972 i_err
= VLC_EGENERIC
;
975 RemoveBase64Padding( psz_aes_key_base64
);
977 /* Encode AES IV in Base64 */
978 psz_aes_iv_base64
= vlc_b64_encode_binary( p_sys
->ps_aes_iv
,
979 sizeof( p_sys
->ps_aes_iv
) );
980 if ( psz_aes_iv_base64
== NULL
)
982 i_err
= VLC_EGENERIC
;
985 RemoveBase64Padding( psz_aes_iv_base64
);
987 /* Random bytes for Apple-Challenge header */
988 gcry_randomize( ps_sac
, sizeof( ps_sac
), GCRY_STRONG_RANDOM
);
990 psz_sac_base64
= vlc_b64_encode_binary( ps_sac
, sizeof( ps_sac
) );
991 if ( psz_sac_base64
== NULL
)
993 i_err
= VLC_EGENERIC
;
996 RemoveBase64Padding( psz_sac_base64
);
999 * Note: IPv6 addresses also use "IP4". Make sure not to include the
1002 i_rc
= asprintf( &psz_sdp
,
1004 "o=iTunes %u 0 IN IP4 %s\r\n"
1008 "m=audio 0 RTP/AVP 96\r\n"
1009 "a=rtpmap:96 AppleLossless\r\n"
1010 "a=fmtp:96 4096 0 16 40 10 14 2 255 0 0 44100\r\n"
1011 "a=rsaaeskey:%s\r\n"
1013 i_session_id
, psz_local
, p_sys
->psz_host
,
1014 psz_aes_key_base64
, psz_aes_iv_base64
);
1022 /* Build and send request */
1023 vlc_dictionary_insert( &req_headers
, "Apple-Challenge", psz_sac_base64
);
1025 i_err
= ExecRequest( p_this
, "ANNOUNCE", "application/sdp", psz_sdp
,
1026 &req_headers
, &resp_headers
);
1027 if ( i_err
!= VLC_SUCCESS
)
1031 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1032 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1035 free( psz_sac_base64
);
1036 free( psz_aes_key_base64
);
1037 free( psz_aes_iv_base64
);
1042 static int SendSetup( vlc_object_t
*p_this
)
1044 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1045 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1046 vlc_dictionary_t req_headers
;
1047 vlc_dictionary_t resp_headers
;
1048 int i_err
= VLC_SUCCESS
;
1054 vlc_dictionary_init( &req_headers
, 0 );
1055 vlc_dictionary_init( &resp_headers
, 0 );
1057 vlc_dictionary_insert( &req_headers
, "Transport",
1058 ((void*)"RTP/AVP/TCP;unicast;interleaved=0-1;"
1061 i_err
= ExecRequest( p_this
, "SETUP", NULL
, NULL
,
1062 &req_headers
, &resp_headers
);
1063 if ( i_err
!= VLC_SUCCESS
)
1066 psz_tmp
= vlc_dictionary_value_for_key( &resp_headers
, "Session" );
1069 msg_Err( p_this
, "Missing 'Session' header during setup" );
1070 i_err
= VLC_EGENERIC
;
1074 free( p_sys
->psz_session
);
1075 p_sys
->psz_session
= strdup( psz_tmp
);
1077 /* Get server_port */
1078 psz_next
= vlc_dictionary_value_for_key( &resp_headers
, "Transport" );
1079 while ( SplitHeader( &psz_next
, &psz_name
, &psz_value
) )
1081 if ( psz_value
&& strcmp( psz_name
, "server_port" ) == 0 )
1083 p_sys
->i_server_port
= atoi( psz_value
);
1088 if ( !p_sys
->i_server_port
)
1090 msg_Err( p_this
, "Missing 'server_port' during setup" );
1091 i_err
= VLC_EGENERIC
;
1096 psz_next
= vlc_dictionary_value_for_key( &resp_headers
,
1097 "Audio-Jack-Status" );
1098 while ( SplitHeader( &psz_next
, &psz_name
, &psz_value
) )
1100 if ( strcmp( psz_name
, "type" ) != 0 )
1103 if ( strcmp( psz_value
, "analog" ) == 0 )
1104 p_sys
->i_jack_type
= JACK_TYPE_ANALOG
;
1106 else if ( strcmp( psz_value
, "digital" ) == 0 )
1107 p_sys
->i_jack_type
= JACK_TYPE_DIGITAL
;
1113 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1114 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1119 static int SendRecord( vlc_object_t
*p_this
)
1121 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1122 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1123 vlc_dictionary_t req_headers
;
1124 vlc_dictionary_t resp_headers
;
1125 int i_err
= VLC_SUCCESS
;
1128 vlc_dictionary_init( &req_headers
, 0 );
1129 vlc_dictionary_init( &resp_headers
, 0 );
1131 vlc_dictionary_insert( &req_headers
, "Range", (void *)"npt=0-" );
1132 vlc_dictionary_insert( &req_headers
, "RTP-Info",
1133 (void *)"seq=0;rtptime=0" );
1134 vlc_dictionary_insert( &req_headers
, "Session",
1135 (void *)p_sys
->psz_session
);
1137 i_err
= ExecRequest( p_this
, "RECORD", NULL
, NULL
,
1138 &req_headers
, &resp_headers
);
1139 if ( i_err
!= VLC_SUCCESS
)
1142 psz_value
= vlc_dictionary_value_for_key( &resp_headers
, "Audio-Latency" );
1144 p_sys
->i_audio_latency
= atoi( psz_value
);
1146 p_sys
->i_audio_latency
= 0;
1149 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1150 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1155 static int SendFlush( vlc_object_t
*p_this
)
1157 VLC_UNUSED( p_this
);
1158 vlc_dictionary_t resp_headers
;
1159 vlc_dictionary_t req_headers
;
1160 int i_err
= VLC_SUCCESS
;
1162 vlc_dictionary_init( &req_headers
, 0 );
1163 vlc_dictionary_init( &resp_headers
, 0 );
1165 vlc_dictionary_insert( &req_headers
, "RTP-Info",
1166 (void *)"seq=0;rtptime=0" );
1168 i_err
= ExecRequest( p_this
, "FLUSH", NULL
, NULL
,
1169 &req_headers
, &resp_headers
);
1170 if ( i_err
!= VLC_SUCCESS
)
1174 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1175 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1180 static int SendTeardown( vlc_object_t
*p_this
)
1182 vlc_dictionary_t resp_headers
;
1183 vlc_dictionary_t req_headers
;
1184 int i_err
= VLC_SUCCESS
;
1186 vlc_dictionary_init( &req_headers
, 0 );
1187 vlc_dictionary_init( &resp_headers
, 0 );
1189 i_err
= ExecRequest( p_this
, "TEARDOWN", NULL
, NULL
,
1190 &req_headers
, &resp_headers
);
1191 if ( i_err
!= VLC_SUCCESS
)
1195 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1196 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1201 static int UpdateVolume( vlc_object_t
*p_this
)
1203 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1204 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1205 vlc_dictionary_t req_headers
;
1206 vlc_dictionary_t resp_headers
;
1207 char *psz_parameters
= NULL
;
1209 int i_err
= VLC_SUCCESS
;
1212 vlc_dictionary_init( &req_headers
, 0 );
1213 vlc_dictionary_init( &resp_headers
, 0 );
1215 /* Our volume is 0..255, RAOP is -144..0 (-144 off, -30..0 on) */
1218 p_sys
->i_volume
= __MAX( 0, __MIN( p_sys
->i_volume
, 255 ) );
1220 if ( p_sys
->i_volume
== 0 )
1223 d_volume
= -30 + ( ( (double)p_sys
->i_volume
) * 30.0 / 255.0 );
1225 /* Format without using locales */
1226 i_rc
= us_asprintf( &psz_parameters
, "volume: %0.6f\r\n", d_volume
);
1233 vlc_dictionary_insert( &req_headers
, "Session",
1234 (void *)p_sys
->psz_session
);
1236 i_err
= ExecRequest( p_this
, "SET_PARAMETER",
1237 "text/parameters", psz_parameters
,
1238 &req_headers
, &resp_headers
);
1239 if ( i_err
!= VLC_SUCCESS
)
1243 vlc_dictionary_clear( &req_headers
, NULL
, NULL
);
1244 vlc_dictionary_clear( &resp_headers
, FreeHeader
, NULL
);
1245 free( psz_parameters
);
1250 static void LogInfo( vlc_object_t
*p_this
)
1252 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1253 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1254 const char *psz_jack_name
;
1256 msg_Info( p_this
, "Audio latency: %d", p_sys
->i_audio_latency
);
1258 switch ( p_sys
->i_jack_type
)
1260 case JACK_TYPE_ANALOG
:
1261 psz_jack_name
= "analog";
1264 case JACK_TYPE_DIGITAL
:
1265 psz_jack_name
= "digital";
1268 case JACK_TYPE_NONE
:
1270 psz_jack_name
= "none";
1274 msg_Info( p_this
, "Jack type: %s", psz_jack_name
);
1277 static void SendAudio( sout_stream_t
*p_stream
, block_t
*p_buffer
)
1279 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1280 gcry_error_t i_gcrypt_err
;
1283 size_t i_payload_len
;
1284 size_t i_realloc_len
;
1287 const uint8_t header
[16] = {
1288 0x24, 0x00, 0x00, 0x00,
1289 0xf0, 0xff, 0x00, 0x00,
1290 0x00, 0x00, 0x00, 0x00,
1291 0x00, 0x00, 0x00, 0x00,
1296 i_len
= sizeof( header
) + p_buffer
->i_buffer
;
1298 /* Buffer resize needed? */
1299 if ( i_len
> p_sys
->i_sendbuf_len
|| p_sys
->p_sendbuf
== NULL
)
1301 /* Grow in blocks of 4K */
1302 i_realloc_len
= (1 + (i_len
/ 4096)) * 4096;
1304 p_sys
->p_sendbuf
= realloc_or_free( p_sys
->p_sendbuf
, i_realloc_len
);
1305 if ( p_sys
->p_sendbuf
== NULL
)
1308 p_sys
->i_sendbuf_len
= i_realloc_len
;
1312 memcpy( p_sys
->p_sendbuf
, header
, sizeof( header
) );
1313 memcpy( p_sys
->p_sendbuf
+ sizeof( header
),
1314 p_buffer
->p_buffer
, p_buffer
->i_buffer
);
1316 /* Calculate payload length and update header */
1317 i_payload_len
= i_len
- 4;
1318 if ( i_payload_len
> 0xffff )
1320 msg_Err( p_stream
, "Buffer is too long (%u bytes)",
1321 (unsigned int)i_payload_len
);
1325 p_sys
->p_sendbuf
[2] = ( i_payload_len
>> 8 ) & 0xff;
1326 p_sys
->p_sendbuf
[3] = i_payload_len
& 0xff;
1329 i_gcrypt_err
= gcry_cipher_reset( p_sys
->aes_ctx
);
1330 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
1334 i_gcrypt_err
= gcry_cipher_setiv( p_sys
->aes_ctx
, p_sys
->ps_aes_iv
,
1335 sizeof( p_sys
->ps_aes_iv
) );
1336 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
1339 /* Encrypt in place. Only full blocks of 16 bytes are encrypted,
1340 * the rest (0-15 bytes) is left unencrypted.
1343 gcry_cipher_encrypt( p_sys
->aes_ctx
,
1344 p_sys
->p_sendbuf
+ sizeof( header
),
1345 ( p_buffer
->i_buffer
/ 16 ) * 16,
1347 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
1351 rc
= net_Write( p_stream
, p_sys
->i_stream_fd
, NULL
,
1352 p_sys
->p_sendbuf
, i_len
);
1356 p_next
= p_buffer
->p_next
;
1357 block_Release( p_buffer
);
1362 block_ChainRelease( p_buffer
);
1367 /*****************************************************************************
1369 *****************************************************************************/
1370 static int Open( vlc_object_t
*p_this
)
1372 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1373 sout_stream_sys_t
*p_sys
;
1374 char psz_local
[NI_MAXNUMERICHOST
];
1375 char *psz_pwfile
= NULL
;
1376 gcry_error_t i_gcrypt_err
;
1377 int i_err
= VLC_SUCCESS
;
1378 uint32_t i_session_id
;
1379 uint64_t i_client_instance
;
1383 config_ChainParse( p_stream
, SOUT_CFG_PREFIX
, ppsz_sout_options
,
1386 p_sys
= calloc( 1, sizeof( *p_sys
) );
1387 if ( p_sys
== NULL
)
1393 p_stream
->p_sys
= p_sys
;
1394 p_stream
->pf_add
= Add
;
1395 p_stream
->pf_del
= Del
;
1396 p_stream
->pf_send
= Send
;
1397 p_stream
->p_sout
->i_out_pace_nocontrol
++;
1399 p_sys
->i_control_fd
= -1;
1400 p_sys
->i_stream_fd
= -1;
1401 p_sys
->i_volume
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"volume");
1402 p_sys
->i_jack_type
= JACK_TYPE_NONE
;
1404 http_auth_Init( &p_sys
->auth
);
1406 p_sys
->psz_host
= var_GetNonEmptyString( p_stream
,
1407 SOUT_CFG_PREFIX
"host" );
1408 if ( p_sys
->psz_host
== NULL
)
1410 msg_Err( p_this
, "Missing host" );
1411 i_err
= VLC_EGENERIC
;
1415 p_sys
->psz_password
= var_GetNonEmptyString( p_stream
,
1416 SOUT_CFG_PREFIX
"password" );
1417 if ( p_sys
->psz_password
== NULL
)
1419 /* Try password file instead */
1420 psz_pwfile
= var_GetNonEmptyString( p_stream
,
1421 SOUT_CFG_PREFIX
"password-file" );
1422 if ( psz_pwfile
!= NULL
)
1424 p_sys
->psz_password
= ReadPasswordFile( p_this
, psz_pwfile
);
1425 if ( p_sys
->psz_password
== NULL
)
1427 i_err
= VLC_EGENERIC
;
1433 if ( p_sys
->psz_password
!= NULL
)
1434 msg_Info( p_this
, "Using password authentication" );
1436 var_AddCallback( p_stream
, SOUT_CFG_PREFIX
"volume",
1437 VolumeCallback
, NULL
);
1438 p_sys
->b_volume_callback
= true;
1440 /* Open control connection */
1441 p_sys
->i_control_fd
= net_ConnectTCP( p_stream
, p_sys
->psz_host
,
1443 if ( p_sys
->i_control_fd
< 0 )
1445 msg_Err( p_this
, "Cannot establish control connection to %s:%d (%m)",
1446 p_sys
->psz_host
, RAOP_PORT
);
1447 i_err
= VLC_EGENERIC
;
1451 /* Get local IP address */
1452 if ( net_GetSockAddress( p_sys
->i_control_fd
, psz_local
, NULL
) )
1454 msg_Err( p_this
, "cannot get local IP address" );
1455 i_err
= VLC_EGENERIC
;
1459 /* Random session ID */
1460 gcry_randomize( &i_session_id
, sizeof( i_session_id
),
1461 GCRY_STRONG_RANDOM
);
1463 /* Random client instance */
1464 gcry_randomize( &i_client_instance
, sizeof( i_client_instance
),
1465 GCRY_STRONG_RANDOM
);
1466 if ( asprintf( &p_sys
->psz_client_instance
, "%016"PRIX64
,
1467 i_client_instance
) < 0 )
1473 /* Build session URL */
1474 if ( asprintf( &p_sys
->psz_url
, "rtsp://%s/%u",
1475 psz_local
, i_session_id
) < 0 )
1481 /* Generate AES key and IV */
1482 gcry_randomize( p_sys
->ps_aes_key
, sizeof( p_sys
->ps_aes_key
),
1483 GCRY_STRONG_RANDOM
);
1484 gcry_randomize( p_sys
->ps_aes_iv
, sizeof( p_sys
->ps_aes_iv
),
1485 GCRY_STRONG_RANDOM
);
1488 i_gcrypt_err
= gcry_cipher_open( &p_sys
->aes_ctx
, GCRY_CIPHER_AES
,
1489 GCRY_CIPHER_MODE_CBC
, 0 );
1490 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
1492 i_err
= VLC_EGENERIC
;
1497 i_gcrypt_err
= gcry_cipher_setkey( p_sys
->aes_ctx
, p_sys
->ps_aes_key
,
1498 sizeof( p_sys
->ps_aes_key
) );
1499 if ( CheckForGcryptError( p_stream
, i_gcrypt_err
) )
1501 i_err
= VLC_EGENERIC
;
1505 /* Protocol handshake */
1506 i_err
= AnnounceSDP( p_this
, psz_local
, i_session_id
);
1507 if ( i_err
!= VLC_SUCCESS
)
1510 i_err
= SendSetup( p_this
);
1511 if ( i_err
!= VLC_SUCCESS
)
1514 i_err
= SendRecord( p_this
);
1515 if ( i_err
!= VLC_SUCCESS
)
1518 i_err
= UpdateVolume( p_this
);
1519 if ( i_err
!= VLC_SUCCESS
)
1524 /* Open stream connection */
1525 p_sys
->i_stream_fd
= net_ConnectTCP( p_stream
, p_sys
->psz_host
,
1526 p_sys
->i_server_port
);
1527 if ( p_sys
->i_stream_fd
< 0 )
1529 msg_Err( p_this
, "Cannot establish stream connection to %s:%d (%m)",
1530 p_sys
->psz_host
, p_sys
->i_server_port
);
1531 i_err
= VLC_EGENERIC
;
1538 if ( i_err
!= VLC_SUCCESS
)
1539 FreeSys( p_this
, p_sys
);
1545 /*****************************************************************************
1547 *****************************************************************************/
1548 static void Close( vlc_object_t
*p_this
)
1550 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1551 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1553 SendFlush( p_this
);
1554 SendTeardown( p_this
);
1556 FreeSys( p_this
, p_sys
);
1558 p_stream
->p_sout
->i_out_pace_nocontrol
--;
1562 /*****************************************************************************
1564 *****************************************************************************/
1565 static sout_stream_id_t
*Add( sout_stream_t
*p_stream
, es_format_t
*p_fmt
)
1567 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1568 sout_stream_id_t
*id
= NULL
;
1570 id
= calloc( 1, sizeof( *id
) );
1574 es_format_Copy( &id
->fmt
, p_fmt
);
1576 switch ( id
->fmt
.i_cat
)
1579 if ( id
->fmt
.i_codec
== VLC_CODEC_ALAC
)
1581 if ( p_sys
->p_audio_stream
)
1583 msg_Warn( p_stream
, "Only the first Apple Lossless audio "
1586 else if ( id
->fmt
.audio
.i_rate
!= 44100 ||
1587 id
->fmt
.audio
.i_channels
!= 2 )
1589 msg_Err( p_stream
, "The Apple Lossless audio stream must be "
1590 "encoded with 44100 Hz and 2 channels" );
1594 /* Use this stream */
1595 p_sys
->p_audio_stream
= id
;
1598 else if ( !p_sys
->b_alac_warning
)
1600 msg_Err( p_stream
, "Apple Lossless is the only codec supported. "
1601 "Use the \"transcode\" module for conversion "
1602 "(e.g. \"transcode{acodec=alac,"
1603 "channels=2}\")." );
1604 p_sys
->b_alac_warning
= true;
1610 /* Leave other stream types alone */
1623 /*****************************************************************************
1625 *****************************************************************************/
1626 static int Del( sout_stream_t
*p_stream
, sout_stream_id_t
*id
)
1628 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1629 int i_err
= VLC_SUCCESS
;
1631 if ( p_sys
->p_audio_stream
== id
)
1632 p_sys
->p_audio_stream
= NULL
;
1640 /*****************************************************************************
1642 *****************************************************************************/
1643 static int Send( sout_stream_t
*p_stream
, sout_stream_id_t
*id
,
1646 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1648 if ( id
->fmt
.i_cat
== AUDIO_ES
&& id
== p_sys
->p_audio_stream
)
1650 /* SendAudio takes care of releasing the buffers */
1651 SendAudio( p_stream
, p_buffer
);
1655 block_ChainRelease( p_buffer
);
1662 /*****************************************************************************
1663 * VolumeCallback: called when the volume is changed on the fly.
1664 *****************************************************************************/
1665 static int VolumeCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
1666 vlc_value_t oldval
, vlc_value_t newval
,
1669 VLC_UNUSED(psz_cmd
);
1673 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
1674 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1676 /* TODO: Implement volume change */