Context Navigation

bvbi_scte.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
Property svn:executable set to ``*
File size: 18.7 KB

Line
1	/***************************************************************************
2	* Copyright (c) 2003-2009, Broadcom Corporation
3	* All Rights Reserved
4	* Confidential Property of Broadcom Corporation
5	*
6	* THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7	* AGREEMENT BETWEEN THE USER AND BROADCOM. YOU HAVE NO RIGHT TO USE OR
8	* EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9	*
10	* $brcm_Workfile: bvbi_scte.c $
11	* $brcm_Revision: Hydra_Software_Devel/3 $
12	* $brcm_Date: 6/24/09 4:58p $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	*
18	* $brcm_Log: /magnum/portinginterface/vbi/7400/bvbi_scte.c $
19	*
20	* Hydra_Software_Devel/3 6/24/09 4:58p darnstein
21	* PR56290: BVBI now compiles for 7342 chipset.
22	*
23	* Hydra_Software_Devel/2 12/3/08 7:57p darnstein
24	* PR45819: New, more modular form of most BVBI source files.
25	*
26	* Hydra_Software_Devel/7 4/4/08 4:11p darnstein
27	* PR41260: (Attempt to) silence a Coverity error.
28	*
29	* Hydra_Software_Devel/6 11/1/07 12:54p darnstein
30	* PR29723: Fix some compiler warnings. Mainly involving unused function
31	* arguments.
32	*
33	* Hydra_Software_Devel/5 10/15/07 11:35a pntruong
34	* PR29723: Fixed linux build warnings.
35	*
36	* Hydra_Software_Devel/4 9/12/07 4:57p darnstein
37	* PR29723: For 7405 SCTE encoder core, account for register differences
38	* with same core in 7403 chipset.
39	*
40	* Hydra_Software_Devel/3 9/11/07 5:18p darnstein
41	* PR25708: First release of SCTE encoder software.
42	*
43	* Hydra_Software_Devel/2 9/7/07 5:28p darnstein
44	* PR25708: Latest experimental version. Version 1 was ancient.
45	*
46	* Hydra_Software_Devel/1 9/7/07 5:02p darnstein
47	* PR25708: support SCTE 20 and SCTE 21 encoding.
48	*
49	***************************************************************************/
50
51	#include "bstd.h" /* standard types */
52	#include "bdbg.h" /* Dbglib */
53	#include "bkni.h" /* For critical sections */
54	#include "bvbi.h" /* VBI processing, this module. */
55	#include "bvbi_priv.h" /* VBI internal data structures */
56
57	BDBG_MODULE(BVBI);
58
59
60	/***************************************************************************
61	* Implementation of "BVBI_" API functions
62	***************************************************************************/
63
64	/***************************************************************************
65	*
66	*/
67	BERR_Code BVBI_Field_GetSCTEData_isr (
68	BVBI_Field_Handle fieldHandle,
69	BVBI_SCTE_Data *pScteData
70	)
71	{
72	BVBI_P_Field_Handle* pVbi_Fld;
73	BVBI_P_SCTE_Data* pData;
74	BVBI_SCTE_CC_Data* cc_data;
75	BVBI_SCTE_NRTV_Data* nrtv_data;
76	BVBI_SCTE_Mono_Data* mono_data;
77	BERR_Code eErr = BERR_SUCCESS;
78	size_t line_count;
79	size_t entry;
80	size_t cc_count = 0;
81	size_t nrtv_count = 0;
82	size_t mono_count = 0;
83
84	BDBG_ENTER(BVBI_Field_GetSCTEData_isr);
85
86	/* check parameters */
87	BVBI_P_GET_FIELD_CONTEXT(fieldHandle, pVbi_Fld);
88	if((!pVbi_Fld) \|\| (!pScteData))
89	{
90	return BERR_TRACE(BERR_INVALID_PARAMETER);
91	}
92
93	/* Verify that data is present on this field handle */
94	if (!(pVbi_Fld->ulWhichPresent & BVBI_P_SELECT_SCTE))
95	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
96	else if (pVbi_Fld->ulErrInfo & BVBI_LINE_ERROR_SCTE_NOENCODE)
97	eErr = (BVBI_ERR_FIELD_BADDATA);
98	pData = pVbi_Fld->pPScteData;
99	if (!pData)
100	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
101
102	pScteData->field_number = pData->field_number;
103
104	/*
105	* Line oriented data
106	*/
107	for (line_count = 0 ; line_count < pData->line_count ; ++line_count)
108	{
109	BVBI_P_SCTE_Line_Data* pLine = &pData->pLine[line_count];
110	switch (pLine->eType)
111	{
112	case BVBI_SCTE_Type_CCONLY:
113	if (cc_count >= pScteData->cc_size)
114	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
115	cc_data = &pScteData->cc_data[cc_count];
116	pScteData->cc_count = ++cc_count;
117	cc_data->valid = pLine->valid;
118	cc_data->priority = pLine->priority;
119	cc_data->line_number = pLine->line_number;
120	cc_data->cc_data_1 = pLine->d.CC.cc_data_1;
121	cc_data->cc_data_2 = pLine->d.CC.cc_data_2;
122	break;
123	case BVBI_SCTE_Type_CCNRTV:
124	if (nrtv_count >= pScteData->nrtv_size)
125	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
126	nrtv_data = &pScteData->nrtv_data[nrtv_count];
127	pScteData->nrtv_count = ++nrtv_count;
128	nrtv_data->valid = pLine->valid;
129	nrtv_data->priority = pLine->priority;
130	nrtv_data->line_number = pLine->line_number;
131	nrtv_data->sequence_number = pLine->d.NRTV.sequence_number;
132	nrtv_data->segment_number = pLine->d.NRTV.segment_number;
133	for (entry = 0 ; entry < 32 ; ++entry)
134	{
135	nrtv_data->y_data[entry] = pData->nrtv_data[0][entry];
136	nrtv_data->cbcr_data[entry] = pData->nrtv_data[1][entry];
137	}
138	break;
139	case BVBI_SCTE_Type_CCMONO:
140	if (mono_count >= pScteData->mono_size)
141	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
142	mono_data = &pScteData->mono_data[mono_count];
143	pScteData->mono_count = ++mono_count;
144	mono_data->first_segment_flag = pLine->d.Mono.first_segment_flag;
145	mono_data->last_segment_flag = pLine->d.Mono.last_segment_flag;
146	mono_data->line_number = pLine->line_number;
147	mono_data->first_pixel_position =
148	pLine->d.Mono.first_pixel_position;
149	mono_data->n_pixels = pLine->d.Mono.n_pixels;
150	for (entry = 0 ; entry < mono_data->n_pixels ; ++entry)
151	{
152	mono_data->Y_data[entry] =
153	pData->mono_data[pLine->d.Mono.iArray][entry];
154	}
155	break;
156	default:
157	return BERR_TRACE(BVBI_ERR_FIELD_BADDATA);
158	break;
159	}
160	}
161
162	/*
163	* PAM data
164	*/
165	if (pData->pam_data_count > pScteData->pam_size)
166	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
167	BKNI_Memcpy (
168	pScteData->luma_PAM_data, pData->pam_data, pData->pam_data_count);
169	pScteData->pam_count = pData->pam_data_count;
170
171	BDBG_LEAVE(BVBI_Field_GetSCTEData_isr);
172	return eErr;
173	}
174
175
176	/***************************************************************************
177	*
178	*/
179	BERR_Code BVBI_Field_GetSCTEData_Count_isr(
180	BVBI_Field_Handle fieldHandle,
181	size_t* pcc_count, size_t* pnrtv_count, size_t* ppam_count,
182	size_t* pmono_count
183	)
184	{
185	BVBI_P_Field_Handle* pVbi_Fld;
186	BVBI_P_SCTE_Data* pData;
187	size_t iLine;
188	BERR_Code eErr = BERR_SUCCESS;
189	size_t cc_count = 0;
190	size_t nrtv_count = 0;
191	size_t mono_count = 0;
192
193	BDBG_ENTER(BVBI_Field_GetSCTEData_Count_isr);
194
195	/* check parameters */
196	BVBI_P_GET_FIELD_CONTEXT(fieldHandle, pVbi_Fld);
197	if(!pVbi_Fld)
198	return BERR_TRACE(BERR_INVALID_PARAMETER);
199	if ((!pcc_count) \|\| (!pnrtv_count) \|\| (!ppam_count) \|\| (!pmono_count))
200	return BERR_TRACE(BERR_INVALID_PARAMETER);
201
202	/* Verify that data is present on this field handle */
203	if (!(pVbi_Fld->ulWhichPresent & BVBI_P_SELECT_SCTE))
204	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
205	else if (pVbi_Fld->ulErrInfo & BVBI_LINE_ERROR_SCTE_NOENCODE)
206	eErr = (BVBI_ERR_FIELD_BADDATA);
207	pData = pVbi_Fld->pPScteData;
208	if (!pData)
209	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
210
211	/* Search for the line oriented data */
212	for (iLine = 0 ; iLine < pData->line_count ; ++iLine)
213	{
214	BVBI_P_SCTE_Line_Data* pLine = &(pData->pLine[iLine]);
215	switch (pLine->eType)
216	{
217	case BVBI_SCTE_Type_CCONLY:
218	++cc_count;
219	break;
220	case BVBI_SCTE_Type_CCNRTV:
221	++nrtv_count;
222	break;
223	case BVBI_SCTE_Type_CCMONO:
224	++mono_count;
225	break;
226	default:
227	break;
228	}
229	}
230
231	/* Return requested data */
232	*pnrtv_count = nrtv_count;
233	*pcc_count = cc_count;
234	*pmono_count = mono_count;
235	*ppam_count = pData->pam_data_count;
236
237	BDBG_LEAVE(BVBI_Field_GetSCTEData_Count_isr);
238	return eErr;
239	}
240
241
242	/***************************************************************************
243	*
244	*/
245	BERR_Code BVBI_Field_GetSCTEData_Size_isr(
246	BVBI_Field_Handle fieldHandle,
247	size_t* pcc_size, size_t* pnrtv_size, size_t* ppam_size, size_t* pmono_size
248	)
249	{
250	BVBI_P_Field_Handle* pVbi_Fld;
251	BVBI_P_SCTE_Data* pData;
252	size_t cc_size;
253	size_t nrtv_size;
254	size_t mono_size;
255	BERR_Code eErr = BERR_SUCCESS;
256
257	BDBG_ENTER(BVBI_Field_GetSCTEData_Size_isr);
258
259	/* check parameters */
260	BVBI_P_GET_FIELD_CONTEXT(fieldHandle, pVbi_Fld);
261	if(!pVbi_Fld)
262	return BERR_TRACE(BERR_INVALID_PARAMETER);
263	if ((!pcc_size) \|\| (!pnrtv_size) \|\| (!ppam_size) \|\| (!pmono_size))
264	return BERR_TRACE(BERR_INVALID_PARAMETER);
265
266	/* Verify that data is present on this field handle */
267	if (!(pVbi_Fld->ulWhichPresent & BVBI_P_SELECT_SCTE))
268	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
269	else if (pVbi_Fld->ulErrInfo & BVBI_LINE_ERROR_SCTE_NOENCODE)
270	eErr = (BVBI_ERR_FIELD_BADDATA);
271	pData = pVbi_Fld->pPScteData;
272	if (!pData)
273	return BERR_TRACE(BVBI_ERR_FIELD_NODATA);
274
275	/* Some simple calculations */
276	nrtv_size = (pData->nrtv_data[0] == 0) ? 0 : 1;
277	mono_size = (pData->mono_data[0] == 0) ? 0 : 2;
278	cc_size = pData->line_size - nrtv_size - mono_size;
279
280	/* Return requested data */
281	*pnrtv_size = nrtv_size;
282	*pcc_size = cc_size;
283	*pmono_size = mono_size;
284	*ppam_size = pData->pam_data_size;
285
286	BDBG_LEAVE(BVBI_Field_GetSCTEData_Size_isr);
287	return eErr;
288	}
289
290
291	/***************************************************************************
292	*
293	*/
294	BERR_Code BVBI_Field_SetSCTEData_isr(
295	BVBI_Field_Handle fieldHandle,
296	BVBI_SCTE_Data *pScteData
297	)
298	{
299	BVBI_P_Field_Handle* pVbi_Fld;
300	BVBI_P_SCTE_Data* pData;
301	int entry;
302	uint32_t cc_line_number;
303	uint32_t nrtv_line_number;
304	uint32_t mono_line_number;
305	size_t cc_count = 0;
306	size_t nrtv_count = 0;
307	size_t mono_count = 0;
308	size_t line_count = 0;
309
310	BDBG_ENTER(BVBI_Field_SetSCTEData_isr);
311
312	/* check parameters */
313	BVBI_P_GET_FIELD_CONTEXT(fieldHandle, pVbi_Fld);
314	if((!pVbi_Fld) \|\| (!pScteData))
315	{
316	BDBG_ERR(("Invalid parameter\n"));
317	return BERR_TRACE(BERR_INVALID_PARAMETER);
318	}
319
320	/* Verify that the field handle can hold SCTE data */
321	pData = pVbi_Fld->pPScteData;
322	if (!pData)
323	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
324
325	/* A few sanity checks */
326	if (pScteData->nrtv_count > 1)
327	return BERR_TRACE(BERR_INVALID_PARAMETER);
328	if (pScteData->mono_count > 2)
329	return BERR_TRACE(BERR_INVALID_PARAMETER);
330	if (pScteData->pam_count > 4095)
331	return BERR_TRACE(BERR_INVALID_PARAMETER);
332
333	pData->field_number = pScteData->field_number;
334
335	/*
336	* Line oriented data. CC, NRTV, and monochrome data must be merged
337	* according to line_number.
338	*/
339	while ((cc_count < pScteData->cc_count ) \|\|
340	(nrtv_count < pScteData->nrtv_count) \|\|
341	(mono_count < pScteData->mono_count) )
342	{
343	BVBI_P_SCTE_Line_Data *pLine = &(pData->pLine[line_count]);
344	if (line_count >= pData->line_size)
345	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
346	if (cc_count < pScteData->cc_count)
347	cc_line_number = pScteData->cc_data[cc_count].line_number;
348	else
349	cc_line_number = 0xFFFFFFFF;
350	if (nrtv_count < pScteData->nrtv_count)
351	nrtv_line_number = pScteData->nrtv_data[nrtv_count].line_number;
352	else
353	nrtv_line_number = 0xFFFFFFFF;
354	if (mono_count < pScteData->mono_count)
355	mono_line_number = pScteData->mono_data[mono_count].line_number;
356	else
357	mono_line_number = 0xFFFFFFFF;
358	if ((cc_line_number <= nrtv_line_number) &&
359	(cc_line_number <= mono_line_number) )
360	{
361	BVBI_SCTE_CC_Data* pCC = &(pScteData->cc_data[cc_count]);
362	if ((pCC->line_number < 10) \|\| (pCC->line_number > 41))
363	return BERR_TRACE(BERR_INVALID_PARAMETER);
364	pLine->valid = pCC->valid;
365	pLine->priority = pCC->priority;
366	pLine->line_number = pCC->line_number;
367	pLine->eType = BVBI_SCTE_Type_CCONLY;
368	pLine->d.CC.cc_data_1 = pCC->cc_data_1;
369	pLine->d.CC.cc_data_2 = pCC->cc_data_2;
370	++cc_count;
371	}
372	else if ((nrtv_line_number <= cc_line_number) &&
373	(nrtv_line_number <= mono_line_number) )
374	{
375	BVBI_SCTE_NRTV_Data* pNRTV = &(pScteData->nrtv_data[nrtv_count]);
376	if ((pNRTV->line_number < 10) \|\| (pNRTV->line_number > 41))
377	return BERR_TRACE(BERR_INVALID_PARAMETER);
378	pLine->valid = pNRTV->valid;
379	pLine->priority = pNRTV->priority;
380	pLine->line_number = pNRTV->line_number;
381	pLine->eType = BVBI_SCTE_Type_CCNRTV;
382	pLine->d.NRTV.sequence_number = pNRTV->sequence_number;
383	pLine->d.NRTV.segment_number = pNRTV->segment_number;
384	for (entry = 0 ; entry < 32 ; ++entry)
385	{
386	pData->nrtv_data[0][entry] = pNRTV->y_data[entry];
387	pData->nrtv_data[1][entry] = pNRTV->cbcr_data[entry];
388	}
389	++nrtv_count;
390	}
391	else /* Process monochrome data */
392	{
393	size_t iBulk;
394	for (iBulk = 0 ; iBulk < pScteData->mono_count ; ++iBulk)
395	{
396	BVBI_SCTE_Mono_Data* pMono =
397	&(pScteData->mono_data[mono_count]);
398	if ((pMono->line_number < 10) \|\| (pMono->line_number > 41))
399	return BERR_TRACE(BERR_INVALID_PARAMETER);
400	pLine->valid = true; /* fake */
401	pLine->priority = 1; /* fake */
402	pLine->line_number = pMono->line_number;
403	pLine->eType = BVBI_SCTE_Type_CCMONO;
404	pLine->d.Mono.first_segment_flag = pMono->first_segment_flag;
405	pLine->d.Mono.last_segment_flag = pMono->last_segment_flag;
406	pLine->d.Mono.first_pixel_position =
407	pMono->first_pixel_position;
408	pLine->d.Mono.n_pixels = pMono->n_pixels;
409	for (entry = 0 ; entry < pMono->n_pixels ; ++entry)
410	{
411	pData->mono_data[iBulk][entry] = pMono->Y_data[entry];
412	}
413	++mono_count;
414	}
415	}
416	pData->line_count = ++line_count;
417	}
418
419	/*
420	* PAM data
421	*/
422	if (pScteData->pam_count > pData->pam_data_size)
423	return BERR_TRACE(BVBI_ERR_FLDH_CONFLICT);
424	BKNI_Memcpy (
425	pData->pam_data, pScteData->luma_PAM_data, pScteData->pam_count);
426	pData->pam_data_count = pScteData->pam_count;
427
428	/* Indicate valid data is present */
429	pVbi_Fld->ulWhichPresent \|= BVBI_P_SELECT_SCTE;
430
431	BDBG_LEAVE(BVBI_Field_SetSCTEData_isr);
432	return BERR_SUCCESS;
433	}
434
435	/***************************************************************************
436	* Implementation of supporting SCTE functions that are not in API
437	***************************************************************************/
438
439	/***************************************************************************
440	*
441	*/
442	BERR_Code BVBI_P_SCTE_Init( BVBI_P_Handle *pVbi )
443	{
444	#if (BVBI_P_NUM_SCTEE == 0)
445	BSTD_UNUSED (pVbi);
446	#else
447	uint8_t hwIndex;
448
449	BDBG_ENTER(BVBI_P_SCTE_Init);
450
451	/* Initialize SCTE encoders */
452	for (hwIndex = 0 ; hwIndex < BVBI_P_NUM_SCTEE ; ++hwIndex)
453	BVBI_P_SCTE_Enc_Init (pVbi->hReg, hwIndex);
454
455	BDBG_LEAVE(BVBI_P_SCTE_Init);
456	#endif
457	return BERR_SUCCESS;
458	}
459
460	/***************************************************************************
461	*
462	*/
463	BERR_Code BVBI_P_SCTEData_Alloc (
464	BMEM_Handle hMem, size_t cc_size, bool scteEnableNrtv, size_t pam_size,
465	bool scteEnableMono, BVBI_P_SCTE_Data* pPScteData)
466	{
467	int iBulk;
468	size_t line_size;
469
470	/*
471	* De-allocate existing data
472	*/
473	if (pPScteData->line_size != 0)
474	{
475	BKNI_Free (pPScteData->pLine);
476	pPScteData->line_size = 0;
477	pPScteData->line_count = 0;
478	}
479	if (pPScteData->nrtv_data[0] != 0)
480	{
481	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
482	{
483	BMEM_Free (hMem, pPScteData->nrtv_data[iBulk]);
484	pPScteData->nrtv_data[iBulk] = 0x0;
485	}
486	}
487	if (pPScteData->pam_data_size != 0)
488	{
489	BMEM_Free (hMem, pPScteData->pam_data);
490	pPScteData->pam_data_size = 0;
491	pPScteData->pam_data_count = 0;
492	}
493	if (pPScteData->mono_data[0] != 0)
494	{
495	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
496	{
497	BMEM_Free (hMem, pPScteData->mono_data[iBulk]);
498	pPScteData->mono_data[iBulk] = 0x0;
499	}
500	}
501
502	/* Allocations for line oriented data */
503	line_size = cc_size;
504	if (scteEnableNrtv)
505	++line_size;
506	if (scteEnableMono)
507	line_size += 2;
508	if (line_size != 0)
509	{
510	pPScteData->pLine =
511	BKNI_Malloc (line_size * sizeof (BVBI_P_SCTE_Line_Data));
512	if (!(pPScteData->pLine))
513	{
514	return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
515	}
516	pPScteData->line_size = line_size;
517	pPScteData->line_count = 0;
518	}
519
520	/*
521	* Allocations for NRTV data
522	*/
523	if (scteEnableNrtv)
524	{
525	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
526	{
527	/* TODO: Change this to BKNI_Malloc. Change length to 32. */
528	pPScteData->nrtv_data[iBulk] =
529	BMEM_AllocAligned (hMem, 704, 4, 0);
530	if (!(pPScteData->nrtv_data[iBulk]))
531	{
532	return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
533	}
534	}
535	}
536
537	/*
538	* Allocation for PAM data
539	*/
540	if (pam_size != 0)
541	{
542	pPScteData->pam_data = BMEM_AllocAligned (hMem, pam_size, 4, 0);
543	if (!(pPScteData->pam_data))
544	{
545	return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
546	}
547	pPScteData->pam_data_size = pam_size;
548	pPScteData->pam_data_count = 0;
549	}
550
551	/*
552	* Allocations for monochrome data
553	*/
554	if (scteEnableMono)
555	{
556	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
557	{
558	/* TODO: Change this to BKNI_Malloc. Change length to 256. */
559	pPScteData->mono_data[iBulk] =
560	BMEM_AllocAligned (hMem, 720, 4, 0);
561	if (!(pPScteData->mono_data[iBulk]))
562	{
563	return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
564	}
565	}
566	}
567
568	return BERR_SUCCESS;
569	}
570
571	/***************************************************************************
572	*
573	*/
574	BERR_Code BVBI_P_Encode_AllocScte (
575	BMEM_Handle hMem,
576	BVBI_LineBuilder_Handle topScteNrtv[2],
577	BVBI_LineBuilder_Handle botScteNrtv[2],
578	BVBI_LineBuilder_Handle topScteMono[2],
579	BVBI_LineBuilder_Handle botScteMono[2],
580	uint8_t** pSctePamData
581	)
582	{
583	int iBulk;
584	BERR_Code eErr;
585
586	/* Allocate empty space for SCTE data */
587	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
588	{
589	if ((eErr = BVBI_LineBuilder_Open (
590	&topScteNrtv[iBulk], hMem, 704, 720)) !=
591	BERR_SUCCESS)
592	{
593	return BERR_TRACE(eErr);
594	}
595	if ((eErr = BVBI_LineBuilder_Open (
596	&botScteNrtv[iBulk], hMem, 704, 720)) !=
597	BERR_SUCCESS)
598	{
599	BVBI_P_Encode_FreeScte (
600	hMem, topScteNrtv, botScteNrtv, topScteMono,
601	botScteMono, pSctePamData);
602	return BERR_TRACE(eErr);
603	}
604	if ((eErr = BVBI_LineBuilder_Open (
605	&topScteMono[iBulk], hMem, 720, 720)) !=
606	BERR_SUCCESS)
607	{
608	BVBI_P_Encode_FreeScte (
609	hMem, topScteNrtv, botScteNrtv, topScteMono,
610	botScteMono, pSctePamData);
611	return BERR_TRACE(eErr);
612	}
613	if ((eErr = BVBI_LineBuilder_Open (
614	&botScteMono[iBulk], hMem, 720, 720)) !=
615	BERR_SUCCESS)
616	{
617	BVBI_P_Encode_FreeScte (
618	hMem, topScteNrtv, botScteNrtv, topScteMono,
619	botScteMono, pSctePamData);
620	return BERR_TRACE(eErr);
621	}
622
623	}
624	*pSctePamData = BMEM_AllocAligned (hMem, 4096, 4, 0);
625	if (!(*pSctePamData))
626	{
627	BVBI_P_Encode_FreeScte (
628	hMem, topScteNrtv, botScteNrtv, topScteMono,
629	botScteMono, pSctePamData);
630	return BERR_TRACE(eErr);
631	}
632	return BERR_SUCCESS;
633	}
634
635	/***************************************************************************
636	*
637	*/
638	void BVBI_P_Encode_FreeScte (
639	BMEM_Handle hMem,
640	BVBI_LineBuilder_Handle topScteNrtv[2],
641	BVBI_LineBuilder_Handle botScteNrtv[2],
642	BVBI_LineBuilder_Handle topScteMono[2],
643	BVBI_LineBuilder_Handle botScteMono[2],
644	uint8_t** pSctePam
645	)
646	{
647	int iBulk;
648
649	for (iBulk = 0 ; iBulk < 2 ; ++iBulk)
650	{
651	if (topScteNrtv[iBulk])
652	{
653	BVBI_LineBuilder_Close (topScteNrtv[iBulk]);
654	topScteNrtv[iBulk] = 0x0;
655	}
656	if (botScteNrtv[iBulk])
657	{
658	BVBI_LineBuilder_Close (botScteNrtv[iBulk]);
659	botScteNrtv[iBulk] = 0x0;
660	}
661	if (topScteMono[iBulk])
662	{
663	BVBI_LineBuilder_Close (topScteMono[iBulk]);
664	topScteMono[iBulk] = 0x0;
665	}
666	if (botScteMono[iBulk])
667	{
668	BVBI_LineBuilder_Close (botScteMono[iBulk]);
669	botScteMono[iBulk] = 0x0;
670	}
671	}
672
673	if (*pSctePam)
674	{
675	BMEM_Free (hMem, *pSctePam);
676	*pSctePam = 0x0;
677	}
678	}
679
680
681	/***************************************************************************
682	* Static (private) functions
683	***************************************************************************/
684
685	/* End of file */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/vbi/7552/bvbi_scte.c

Download in other formats: