stream_filter: add ARIB STD-B25 virtual cam module
[vlc.git] / modules / stream_filter / aribcam.c
1 /*****************************************************************************
2  * aribcam.c : ARIB STB-B25 software CAM stream filter
3  *****************************************************************************
4  * Copyright (C) 2014 VideoLAN and authors
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation; either version 2.1 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
19  *****************************************************************************/
20
21 #ifdef HAVE_CONFIG_H
22 # include "config.h"
23 #endif
24
25 #include <vlc_common.h>
26 #include <vlc_plugin.h>
27 #include <vlc_stream.h>
28
29 #include <inttypes.h>
30 #include <assert.h>
31
32 #include <arib-std-b25/arib_std_b25.h>
33 #include <arib-std-b25/arib_std_b25_error_code.h>
34 #include <arib-std-b25/b_cas_card.h>
35 #include <arib-std-b25/b_cas_card_error_code.h>
36
37 static int  Open(vlc_object_t *);
38 static void Close(vlc_object_t *);
39
40 vlc_module_begin ()
41     set_category (CAT_INPUT)
42     set_subcategory (SUBCAT_INPUT_STREAM_FILTER)
43     set_capability ("stream_filter", 0)
44     add_shortcut("aribcam")
45     set_description (N_("ARIB STD-B25 Cam module"))
46     set_callbacks (Open, Close)
47 vlc_module_end ()
48
49 struct error_messages_s
50 {
51     const int8_t i_error;
52     const char * const psz_error;
53 };
54
55 static const struct error_messages_s const b25_errors[] =
56 {
57     { ARIB_STD_B25_ERROR_INVALID_PARAM, "Invalid parameter" },
58     { ARIB_STD_B25_ERROR_NO_ENOUGH_MEMORY , "Not enough memory" },
59     { ARIB_STD_B25_ERROR_NON_TS_INPUT_STREAM, "Non TS input stream" },
60     { ARIB_STD_B25_ERROR_NO_PAT_IN_HEAD_16M, "No PAT in first 16MB" },
61     { ARIB_STD_B25_ERROR_NO_PMT_IN_HEAD_32M, "No PMT in first 32MB" },
62     { ARIB_STD_B25_ERROR_NO_ECM_IN_HEAD_32M, "No ECM in first 32MB" },
63     { ARIB_STD_B25_ERROR_EMPTY_B_CAS_CARD, "Empty BCAS card" },
64     { ARIB_STD_B25_ERROR_INVALID_B_CAS_STATUS, "Invalid BCAS status" },
65     { ARIB_STD_B25_ERROR_ECM_PROC_FAILURE, "ECM Proc failure" },
66     { ARIB_STD_B25_ERROR_DECRYPT_FAILURE, "Decryption failure" },
67     { ARIB_STD_B25_ERROR_PAT_PARSE_FAILURE, "PAT Parsing failure" },
68     { ARIB_STD_B25_ERROR_PMT_PARSE_FAILURE, "PMT Parsing failure" },
69     { ARIB_STD_B25_ERROR_ECM_PARSE_FAILURE, "ECM Parsing failure" },
70     { ARIB_STD_B25_ERROR_CAT_PARSE_FAILURE, "CAT Parsing failure" },
71     { ARIB_STD_B25_ERROR_EMM_PARSE_FAILURE, "EMM Parsing failure" },
72     { ARIB_STD_B25_ERROR_EMM_PROC_FAILURE, "EMM Proc failure" },
73     { 0, NULL },
74 };
75
76 static const struct error_messages_s const bcas_errors[] =
77 {
78     { B_CAS_CARD_ERROR_INVALID_PARAMETER, "Invalid parameter" },
79     { B_CAS_CARD_ERROR_NOT_INITIALIZED, "Card not initialized" },
80     { B_CAS_CARD_ERROR_NO_SMART_CARD_READER, "No smart card reader" },
81     { B_CAS_CARD_ERROR_ALL_READERS_CONNECTION_FAILED, "Reader connection failed" },
82     { B_CAS_CARD_ERROR_NO_ENOUGH_MEMORY, "Not enough memory" },
83     { B_CAS_CARD_ERROR_TRANSMIT_FAILED, "Transmission failed" },
84     { 0, NULL },
85 };
86
87 struct stream_sys_t
88 {
89     ARIB_STD_B25 *p_b25;
90     B_CAS_CARD   *p_bcas;
91     struct
92     {
93         uint8_t *p_buf;
94         size_t   i_size;
95         block_t *p_list;
96     } remain;
97
98     size_t i_pos;
99     bool   b_unitsizeset;
100 };
101
102 static int Peek( stream_t *, const uint8_t **, unsigned int );
103
104 static const char * GetErrorMessage( const int i_error,
105                                const struct error_messages_s const *p_errors_messages )
106 {
107     int i = 0;
108     while( p_errors_messages[i].psz_error )
109     {
110         if ( p_errors_messages[i].i_error == i_error )
111             return p_errors_messages[i].psz_error;
112         i++;
113     }
114     return "unkown error";
115 }
116
117 static size_t RemainRead( stream_t *p_stream, uint8_t *p_data, size_t i_toread, bool b_peek )
118 {
119     stream_sys_t *p_sys = p_stream->p_sys;
120
121     size_t i_total = 0;
122
123     while( p_sys->remain.p_list && i_toread )
124     {
125         size_t i_copy = __MIN( i_toread, p_sys->remain.p_list->i_buffer );
126         memcpy( p_data, p_sys->remain.p_list->p_buffer, i_copy );
127
128         i_toread -= i_copy;
129         i_total += i_copy;
130         p_data += i_copy;
131
132         if ( !b_peek )
133         {
134             /* update block data pointer and release if no longer needed */
135             p_sys->remain.p_list->i_buffer -= i_copy;
136             p_sys->remain.p_list->p_buffer += i_copy;
137             p_sys->remain.i_size -= i_copy;
138
139             if ( p_sys->remain.p_list->i_buffer == 0 )
140             {
141                 block_t *p_prevhead = p_sys->remain.p_list;
142                 p_sys->remain.p_list = p_sys->remain.p_list->p_next;
143                 block_Release( p_prevhead );
144             }
145         }
146         else
147             p_sys->remain.p_list = p_sys->remain.p_list->p_next;
148     }
149     return i_total;
150 }
151
152 static bool RemainAdd( stream_t *p_stream, const uint8_t *p_data, size_t i_size )
153 {
154     stream_sys_t *p_sys = p_stream->p_sys;
155     if ( i_size == 0 )
156         return true;
157     block_t *p_block = block_Alloc( i_size );
158     if ( !p_block )
159         return false;
160     memcpy( p_block->p_buffer, p_data, i_size );
161     p_block->i_buffer = i_size;
162     block_ChainAppend( & p_sys->remain.p_list, p_block );
163     p_sys->remain.i_size += i_size;
164     return true;
165 }
166
167 static void RemainFlush( stream_sys_t *p_sys )
168 {
169     block_ChainRelease( p_sys->remain.p_list );
170     p_sys->remain.p_list = NULL;
171     p_sys->remain.i_size = 0;
172 }
173
174 #define ALL_READY (UNIT_SIZE_READY|ECM_READY|PMT_READY)
175
176 static int DecoderRead( stream_t *p_stream, uint8_t *p_dst, int i_toread, bool b_peek )
177 {
178     stream_sys_t *p_sys = p_stream->p_sys;
179     ARIB_STD_B25_BUFFER getbuf = { NULL, 0 };
180     int i_total_read = 0;
181     int i_ret;
182
183     if ( !p_dst || ! i_toread )
184         return -1;
185
186     /* Use data from previous reads */
187     size_t i_fromremain = RemainRead( p_stream, p_dst, i_toread, b_peek );
188     i_toread -= i_fromremain;
189     i_total_read += i_fromremain;
190
191     while( i_toread )
192     {
193
194         do
195         {
196             getbuf.size = 0;
197
198             i_ret = p_sys->p_b25->get( p_sys->p_b25, &getbuf );
199             if ( i_ret < 0 )
200                 msg_Err( p_stream, "decoder get failed: %s",
201                          GetErrorMessage( i_ret, b25_errors ) );
202
203             /* If the decoders needs buffering or data is not ready, push some */
204             if ( i_ret == 0 && getbuf.size == 0 )
205             {
206                 /* make use of the existing buffer,
207                overwritten by decoder data later */
208                 int i_srcread = stream_Read( p_stream->p_source, p_dst, i_toread );
209                 if ( i_srcread > 0 )
210                 {
211                     ARIB_STD_B25_BUFFER putbuf = { p_dst, i_srcread };
212                     i_ret = p_sys->p_b25->put( p_sys->p_b25, &putbuf );
213                     if ( i_ret < 0 )
214                         msg_Err( p_stream, "decoder put failed: %s",
215                                  GetErrorMessage( i_ret, b25_errors ) );
216                 }
217                 else
218                 {
219                     if ( i_srcread < 0 )
220                         msg_Err( p_stream, "Can't read %d bytes from source stream: %d", i_toread, i_srcread );
221                     i_ret = -1;
222                 }
223             }
224         }
225         while ( i_ret == 0 && getbuf.size == 0 );
226
227         if ( i_ret < 0 )
228             return -1;
229
230         if ( b_peek )
231         {
232             /* put everything in remain */
233             RemainAdd( p_stream, getbuf.data, getbuf.size );
234         }
235         else
236         {
237             memcpy( p_dst, getbuf.data, __MIN(getbuf.size, i_toread) );
238
239             if ( getbuf.size > i_toread )
240             {
241                 /* Hold remaining data for next call */
242                 RemainAdd( p_stream, getbuf.data + i_toread, getbuf.size - i_toread );
243             }
244         }
245
246         i_total_read += __MIN(getbuf.size, i_toread);
247         p_dst += __MIN(getbuf.size, i_toread);
248         i_toread -= __MIN(getbuf.size, i_toread);
249
250     }
251
252     return i_total_read;
253 }
254
255 static int Read( stream_t *p_stream, void *p_buf, unsigned int i_toread )
256 {
257     stream_sys_t *p_sys = p_stream->p_sys;
258
259     /* We force unit size from 1st TS packet as the lib wants to auto detect
260        size but requires larger amount of data for that purpose */
261     if ( !p_sys->b_unitsizeset )
262     {
263         if ( i_toread >= 188 && i_toread <= 320 )
264             p_sys->b_unitsizeset = ! p_sys->p_b25->set_unit_size( p_sys->p_b25, i_toread );
265         if ( !p_sys->b_unitsizeset )
266             msg_Warn( p_stream, "Unit size not set." );
267         else
268             msg_Dbg( p_stream, "Set unit size to %u", i_toread );
269     }
270
271     int i_read = DecoderRead( p_stream, p_buf, i_toread, false );
272     if ( i_read < 0 )
273         return -1;
274     else
275         p_sys->i_pos += i_read;
276     return i_read;
277 }
278
279 /**
280  *
281  */
282
283 static int Peek( stream_t *p_stream, const uint8_t **pp_buf, unsigned int i_len )
284 {
285     stream_sys_t *p_sys = p_stream->p_sys;
286     i_len = __MAX(ARIB_STD_B25_TS_PROBING_MIN_DATA, i_len);
287
288     if ( i_len > p_sys->remain.i_size )
289     {
290         uint8_t *p_tmpbuf = malloc( i_len - p_sys->remain.i_size );
291         DecoderRead( p_stream, p_tmpbuf, i_len - p_sys->remain.i_size, true );
292         free( p_tmpbuf );
293     }
294
295     if ( !p_sys->remain.p_list )
296     {
297         assert(p_sys->remain.i_size == 0);
298         /* might not be enough data in the stream to allow returning data */
299         return 0;
300     }
301
302     if ( p_sys->remain.p_list->i_buffer < i_len )
303     {
304         p_sys->remain.p_list = block_ChainGather( p_sys->remain.p_list );
305         if ( !p_sys->remain.p_list )
306         {
307             p_sys->remain.i_size = 0;
308             return 0;
309         }
310     }
311
312     *pp_buf = p_sys->remain.p_list->p_buffer;
313
314     return __MIN(i_len, p_sys->remain.i_size);
315 }
316
317 static int Seek( stream_t *p_stream, uint64_t i_pos )
318 {
319     int i_ret = stream_Seek( p_stream->p_source, i_pos );
320     if ( i_ret == VLC_SUCCESS )
321     {
322         RemainFlush( p_stream->p_sys );
323         p_stream->p_sys->i_pos = i_pos;
324     }
325     return i_ret;
326 }
327
328 /**
329  *
330  */
331 static int Control( stream_t *p_stream, int i_query, va_list args )
332 {
333     switch( i_query )
334     {
335     case STREAM_GET_POSITION:
336         *va_arg( args, uint64_t *) = p_stream->p_sys->i_pos;
337         return VLC_SUCCESS;
338     case STREAM_SET_POSITION:
339         return Seek( p_stream, va_arg( args, uint64_t ) );
340     default:
341         return stream_vaControl( p_stream->p_source, i_query, args );
342     }
343 }
344
345 static int Open( vlc_object_t *p_object )
346 {
347     stream_t *p_stream = (stream_t *) p_object;
348
349     int64_t i_stream_size = stream_Size( p_stream->p_source );
350     if ( i_stream_size > 0 && i_stream_size < ARIB_STD_B25_TS_PROBING_MIN_DATA )
351         return VLC_EGENERIC;
352
353     stream_sys_t *p_sys = p_stream->p_sys = calloc( 1, sizeof(*p_sys) );
354     if (p_sys == NULL)
355         return VLC_ENOMEM;
356
357     p_sys->p_b25 = create_arib_std_b25();
358     if ( p_sys->p_b25 )
359     {
360         if ( p_sys->p_b25->set_multi2_round( p_sys->p_b25, 4 ) < 0 )
361             msg_Warn( p_stream, "cannot set B25 round number" );
362
363         if ( p_sys->p_b25->set_strip( p_sys->p_b25, 0 ) < 0 )
364             msg_Warn( p_stream, "cannot set B25 strip option" );
365
366         if ( p_sys->p_b25->set_emm_proc( p_sys->p_b25, 0 ) < 0 )
367             msg_Warn( p_stream, "cannot set B25 emm_proc" );
368
369         p_sys->p_bcas = create_b_cas_card();
370         if ( p_sys->p_bcas )
371         {
372             int i_code = p_sys->p_bcas->init( p_sys->p_bcas );
373             if ( i_code < 0 )
374             {
375                 /* Card could be just missing */
376                 msg_Warn( p_stream, "cannot initialize BCAS card (missing ?): %s",
377                           GetErrorMessage( i_code, bcas_errors ) );
378                 goto error;
379             }
380
381             B_CAS_ID bcasid;
382             if ( p_sys->p_bcas->get_id( p_sys->p_bcas, &bcasid ) == 0 )
383             {
384                 for ( int32_t i=0; i<bcasid.count; i++)
385                 {
386                     msg_Dbg( p_stream, "BCAS card id 0x%"PRId64" initialized",
387                              bcasid.data[i] );
388                 }
389             }
390
391             B_CAS_INIT_STATUS bcas_status;
392             if ( p_sys->p_bcas->get_init_status( p_sys->p_bcas, &bcas_status ) == 0 )
393             {
394                 msg_Dbg( p_stream, "BCAS card system id 0x%"PRIx32,
395                          bcas_status.ca_system_id );
396             }
397
398             i_code = p_sys->p_b25->set_b_cas_card( p_sys->p_b25, p_sys->p_bcas );
399             if ( i_code < 0 )
400             {
401                 msg_Err( p_stream, "cannot attach BCAS card to decoder: %s",
402                          GetErrorMessage( i_code, bcas_errors ) );
403                 goto error;
404             }
405         }
406         else
407             msg_Err( p_stream, "cannot create BCAS card" );
408     }
409     else
410     {
411         msg_Err( p_stream, "cannot create B25 instance" );
412         goto error;
413     }
414
415     p_sys->i_pos = stream_Tell( p_stream->p_source );
416
417     p_stream->pf_read = Read;
418     p_stream->pf_peek = Peek;
419     p_stream->pf_control = Control;
420
421     return VLC_SUCCESS;
422
423 error:
424     Close( VLC_OBJECT(p_stream) );
425     return VLC_EGENERIC;
426 }
427
428 static void Close ( vlc_object_t *p_object )
429 {
430     stream_t *p_stream = (stream_t *)p_object;
431     stream_sys_t *p_sys = p_stream->p_sys;
432
433     if ( p_sys->p_bcas )
434         p_sys->p_bcas->release( p_sys->p_bcas );
435
436     if ( p_sys->p_b25 )
437         p_sys->p_b25->release( p_sys->p_b25 );
438
439     free( p_sys );
440 }