source: svn/branches/kctv/newcon3bcm2_21bu/magnum/commonutils/avc/7552/bavc_hdmi.c

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 30.1 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2012, 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: bavc_hdmi.c $
11 * $brcm_Revision: Hydra_Software_Devel/13 $
12 * $brcm_Date: 1/12/12 3:29p $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log: Q:/projects/7425/latest/magnum/commonutils/avc/7425/bavc_hdmi.c $
19 *
20 * Hydra_Software_Devel/13   1/12/12 3:29p rgreen
21 * SW7429-43: add HBR audio packet support
22 *
23 * Hydra_Software_Devel/12   2/11/11 2:43p rgreen
24 * SW35230-3014: Add support for YCC Qunatization and IT Content Type
25 * fields in AVI InfoFrame
26 *
27 * Hydra_Software_Devel/11   12/2/10 2:43p rgreen
28 * SW35230-2374: add support to verify HDCP keys stored in OTP
29 *
30 * Hydra_Software_Devel/10   4/27/10 10:20p rgreen
31 * SW7405-3997: Update debug info for VSI fields
32 *
33 * Hydra_Software_Devel/9   4/16/10 2:20p rgreen
34 * SW7405-3997: Rename "Reserved for future use" text to "Top-and-Bottom"
35 *
36 * Hydra_Software_Devel/8   4/5/10 11:57p rgreen
37 * SW7405-3994,SW7405-3997: Fix compilation for HDMI Rx
38 *
39 * Hydra_Software_Devel/SW7401-4363/1   4/5/10 6:25p rgreen
40 * SW7405-3994,SW7405-3997: Fix compilation for HDMI Rx vs Tx
41 *
42 * Hydra_Software_Devel/6   3/15/10 5:13p rgreen
43 * SW3548-2820: Add support for  VS Infoframe 3D Structure and Ext Data
44 * fields
45 *
46 * Hydra_Software_Devel/5   1/13/10 4:51p rgreen
47 * SW3548-2708,SW7401-4355:
48 * Add enumerations for Vendor Specific InfoFrame
49 * Add enumeration to string functions for Vendor Specific InfoFrame
50 *
51 * Hydra_Software_Devel/4   10/13/09 1:07p rgreen
52 * SW3548-2013: Add support for SPD InfoFrame debugging
53 *
54 * Hydra_Software_Devel/3   10/5/09 10:30a rgreen
55 * SW3548-2013: change packet type debug messages from numbers to text
56 *
57 * Hydra_Software_Devel/2   5/15/09 11:48a rgreen
58 * PR54000: Add conversion debug functions for Video Id Code (VIC) to
59 * string
60 *
61 * Hydra_Software_Devel/1   5/12/09 6:19p rgreen
62 * PR54000: Add debug enum to string conversion functions
63 *
64 ***************************************************************************/
65
66
67#include "bavc.h"
68#include "bavc_hdmi.h"
69
70
71BDBG_MODULE(BAVC_HDMI) ;
72
73
74static const char EnumError[] = "Enum Error" ;
75static const char Reserved[] = "Reserved" ;
76static const char BAVC_HDMI_P_PacketTypeUnknown[] = "Unknown" ;
77
78typedef struct
79{
80        BAVC_HDMI_PacketType ePacketType ;
81        const char *PacketName ;
82} BAVC_HDMI_PacketTypes ;
83
84static BAVC_HDMI_PacketTypes PacketTypes_Text[] =
85{
86        {BAVC_HDMI_PacketType_eAudioClockRegeneration, "Audio Clock Regeneration"},
87        {BAVC_HDMI_PacketType_eAudioSample, "Audio Sample"},
88        {BAVC_HDMI_PacketType_eGeneralControl, "General Control"},
89        {BAVC_HDMI_PacketType_eAudioContentProtection, "ACP"},
90        {BAVC_HDMI_PacketType_eISRC1, "ISRC1"},
91        {BAVC_HDMI_PacketType_eISRC2, "ISRC2"},
92        {BAVC_HDMI_PacketType_eDirectStream, "One Bit Audio Stream"},
93        {BAVC_HDMI_PacketType_eHbrAudioPacket, "High Bitrate (HBR) Audio"},
94
95#if BAVC_HDMI_1_3_SUPPORT
96        {BAVC_HDMI_PacketType_eGamutMetadataPacket, "Gamut Metadata"},
97#endif
98       
99        {BAVC_HDMI_PacketType_eVendorSpecificInfoframe, "Vendor Specific InfoFrame"},
100        {BAVC_HDMI_PacketType_eAviInfoFrame, "AVI InfoFrame"},
101        {BAVC_HDMI_PacketType_eSpdInfoFrame, "SPD InfoFrame"},
102        {BAVC_HDMI_PacketType_eAudioInfoFrame, "Audio InfoFrame" },
103        {BAVC_HDMI_PacketType_eMpegInfoFrame, "MPEG Source InfoFrame"}
104} ;
105
106
107
108static const char *BAVC_HDMI_AviInfoFrame_Text_Y1Y0[] =
109{
110        "RGB (Default)",
111        "YCbCr 4:2:2",
112        "YCbCr 4:4:4",
113        "Future",
114} ;
115
116static const char *BAVC_HDMI_AviInfoFrame_Text_A0[] =
117{
118        "No Data",
119        "Valid Data"
120} ;
121
122static const char *BAVC_HDMI_AviInfoFrame_Text_B1B0[] =
123{
124        "Invalid Bar Data",
125        "Valid Vert Bar Info",
126        "Vaild Horz Bar Info",
127        "Valid Bar Info"
128} ;
129
130
131static const char *BAVC_HDMI_AviInfoFrame_Text_S1S0[] =
132{
133        "No Data",
134        "Overscan",
135        "Underscan",
136        "Future"
137} ;
138
139
140static const char *BAVC_HDMI_AviInfoFrame_Text_C1C0[] =
141{
142        "No Data",
143        "ITU601",
144        "ITU709",
145        "Extended Colorimetry Info Valid"
146} ;
147
148
149static const char *BAVC_HDMI_AviInfoFrame_Text_M1M0[] =
150{
151        "No Data",
152        "4:3",
153        "16:9",
154        "Future"
155} ;
156
157
158static const char *BAVC_HDMI_AviInfoFrame_Text_R3_R0[] =
159{
160        "Same as Picture AR",
161        "4:3 Center",
162        "16:9 Center",
163        "14:9 Center",
164        "Per DVB AFD active_format in ETSI"
165} ;
166
167
168static const char *BAVC_HDMI_AviInfoFrame_Text_ITC[] =
169{
170        "No Data",
171        "IT content",
172} ;
173
174
175static const char *BAVC_HDMI_AviInfoFrame_Text_EC2_EC0[] =
176{
177        "xvYCC 601",
178        "xvYCC 709",
179        "Reserved"
180} ;
181
182
183static const char *BAVC_HDMI_AviInfoFrame_Text_Q1Q0[] =
184{
185        "Based on format",
186        "Limited Range",
187        "Full Range",
188        "Reserved"
189} ;
190
191
192static const char *BAVC_HDMI_AviInfoFrame_Text_SC1SC0[] =
193{
194        "No Known non-uniform scaling",
195        "Picture Horizontally Scaled",
196        "Picture Vertically Scaled",
197        "Picute Scaled Vertically and Horizontally"
198} ;
199
200static const char *BAVC_HDMI_AviInfoFrame_Text_VIC[] =
201{
202        "Unknown/IT Format",
203        "640x480p  59.94Hz/60Hz", 
204        "720x480p  59.94Hz/60Hz", 
205        "720x480p  59.94Hz/60Hz", 
206        "1280x720p  59.94Hz/60Hz",
207        "1920x1080i  59.94Hz/60Hz", 
208        "720(1440)x480i 59.94Hz/60Hz", 
209        "720(1440)x480i 59.94Hz/60Hz", 
210        "720(1440)x240p 59.94Hz/60Hz", 
211        "720(1440)x240p 59.94Hz/60Hz", 
212        "2880x480i  59.94Hz/60Hz", 
213        "2880x480i  59.94Hz/60Hz", 
214        "2880x240p  59.94Hz/60Hz", 
215        "2880x240p  59.94Hz/60Hz", 
216        "1440x480p  59.94Hz/60Hz", 
217        "1440x480p  59.94Hz/60Hz", 
218        "1920x1080p 59.94Hz/60Hz", 
219        "720x576p 50Hz", 
220        "720x576p 50Hz", 
221        "1280x720p 50Hz", 
222        "1920x1080i 50Hz", 
223        "720(1440)x576i 50Hz", 
224        "720(1440)x576i 50Hz", 
225        "720(1440)x288p 50Hz", 
226        "720(1440)x288p 50Hz", 
227        "2880x576i 50Hz", 
228        "2880x576i 50Hz", 
229        "2880x288p 50Hz", 
230        "2880x288p 50Hz", 
231        "1440x576p 50Hz", 
232        "1440x576p 50Hz", 
233        "1920x1080p 50Hz", 
234        "1920x1080p 23.97Hz/24Hz", 
235        "1920x1080p 25Hz", 
236        "1920x1080p 29.97Hz/30Hz", 
237        "2880x480p 59.94Hz/60Hz", 
238        "2880x480p 59.94Hz/60Hz", 
239        "2880x576p 50Hz",
240        "2880x576p 50Hz",
241        "1920x1080i (1250 total) 50Hz",
242        "1920x1080i 100Hz", 
243        "1280x720p  100Hz", 
244        "720x576p 100Hz", 
245        "720x576p 100Hz", 
246        "720(1440)x576i 100Hz", 
247        "720(1440)x576i 100Hz", 
248        "1920x1080i 119.88/120Hz", 
249        "1280x720p  119.88/120Hz", 
250        "720x480p   119.88/120Hz", 
251        "720x480p   119.88/120Hz",
252        "720(1440)x480i 119.88/120Hz", 
253        "720(1440)x480i 119.88/120Hz", 
254        "720x576p 200Hz", 
255        "720x576p 200Hz", 
256        "720(1440)x576i 200Hz", 
257        "720(1440)x576i 200Hz", 
258        "720x480p 239.76/240Hz", 
259        "720x480p 239.76/240Hz", 
260        "720(1440)x480i 239.76/240Hz",
261        "720(1440)x480i 239.76/240Hz", 
262        "1280x720p 23.97Hz/24Hz", 
263        "1280x720p 25Hz", 
264        "1280x720p 29.97Hz/30Hz",
265        "1920x1080p 119.88/120Hz",
266        "1920x1080p 100Hz"
267} ;
268
269
270static const char *BAVC_HDMI_AviInfoFrame_Text_YQ1YQ0[] =
271{
272        "Limited Range",
273        "Full Range",
274        "Reserved (2)"
275        "Reserved(3)"
276} ;
277
278
279static const char *BAVC_HDMI_AviInfoFrame_Text_CN1CN0[] =
280{
281        "Graphics",
282        "Photo",
283        "Cinema"
284        "Game"
285} ;
286
287
288
289/************************************* Audio Info Frame ****************************************
290***********************************************************************************************/
291
292static const char *BAVC_HDMI_AudioInfoFrame_Text_CT3_CT0[] =
293{
294        "Refer To Stream Header",
295        "PCM [24, 25]",
296        "AC3",
297        "MPEG1",
298        "MPEG 2 [multi-chan]",
299        "AAC",
300        "DTS",
301        "ATRAC",
302        "One-bit",
303        "DDP",
304        "DTS-HD",
305        "MAT[MLP]",
306        "DST",
307        "WMA Pro",
308        "Reserved"                     
309} ;
310
311
312static const char *BAVC_HDMI_AudioInfoFrame_Text_CC2_CC0[] =
313{
314        "Refer To Stream Header",       "2 ch",
315        "3 ch", "4 ch",
316        "5 ch", "6 ch",
317        "7 ch", "8 ch" 
318} ;
319
320static const char *BAVC_HDMI_AudioInfoFrame_Text_SF2_SF0[] =
321{
322        "Refer To Stream Header",
323        "32 kHz",
324        "44.1 kHz (CD)",
325        "48 kHz",
326        "88.2 kHz",
327        "96 kHz",
328        "176.4 kHz",
329        "192 kHz",     
330} ;
331
332static const char *BAVC_HDMI_AudioInfoFrame_Text_SS1SS0[] =
333{
334        "Refer To Stream Header",
335        "16 bit",
336        "20 bit",
337        "24 bit"       
338} ;
339
340static const char *BAVC_HDMI_AudioInfoFrame_Text_LSV3_LSV0[] =
341{
342        "0 db", "1 db", "2 db", "3 db",
343        "4 db", "5 db", "6 db", "7 db",
344        "8 db", "9 db", "10 db",        "11 db",
345        "12 db",        "13 db",        "14 db",        "15 db" 
346} ;
347
348static const char *BAVC_HDMI_AudioInfoFrame_Text_DM[] =
349{
350        "Permitted",
351        "Prohibited"
352} ;
353
354static const char *BAVC_HDMI_SpdInfoFrame_Text_SourceType[] =
355{
356        "unknown",
357        "Digital STB",
358        "DVD player",
359        "D-VHS",
360        "HDD Videorecorder",
361        "DVC",
362        "DSC",
363        "Video CD",
364        "Game",
365        "PC general",
366        "Blu-Ray Disc (BD)",
367        "Super Audio CD",
368        "HD DVD",
369        "PMP"
370} ;
371
372
373static const char *BAVC_HDMI_VsInfoFrame_Text_HdmiVideoFormat[] =
374{
375        "No Add'l HDMI Format",
376        "Extended Resolution Format",
377        "3D Format"
378} ;
379
380
381static const char *BAVC_HDMI_VsInfoFrame_Text_3DStructure[]=
382{
383        "FramePacking",
384        "FieldAlternative",
385        "LineAlternative",
386        "SidexSideFull",
387        "LDepth",
388        "LDepthGraphics",
389        "Top-and-Bottom",
390        "Reserved for future use",
391        "SidexSideHalf",
392        "3D Structure MAX"
393} ;
394
395static const char *BAVC_HDMI_VsInfoFrame_Text_3DExtData[]=
396{
397        "None/HorzOLOR = 0",
398        "HorzOLER",
399        "HorzELOR",
400        "HorzELER",
401        "QuinOLOR",
402        "QuinOLER",
403        "QuinELOR",
404        "QuinELER",
405        "Max"
406} ;
407
408
409static const char *BAVC_HDMI_VsInfoFrame_Text_HDMIVIC[]=
410{
411        "Reserved",
412        "4Kx2K_2997_30Hz",
413        "4Kx2K_25Hz",
414        "4Kx2K_2398_24Hz",
415        "4Kx2K_SMPTE_24Hz",
416        "MAX HDMI VICs"
417} ;
418
419
420/******************************************************************************
421Summary:
422Return character string for Colorspace (Y1Y0) enumeration
423*******************************************************************************/
424const char * BAVC_HDMI_AviInfoFrame_ColorspaceToStr(
425        BAVC_HDMI_AviInfoFrame_Colorspace uiY1Y0)
426{
427        uint8_t entries ;
428       
429        entries = 
430                sizeof(BAVC_HDMI_AviInfoFrame_Text_Y1Y0) / 
431                sizeof(*BAVC_HDMI_AviInfoFrame_Text_Y1Y0) ;
432
433        if (uiY1Y0 < entries)
434                return BAVC_HDMI_AviInfoFrame_Text_Y1Y0[uiY1Y0] ;
435        else
436                return EnumError ;
437}
438       
439
440/******************************************************************************
441Summary:
442Return character string for Active Format (A0) enumeration
443*******************************************************************************/
444const char * BAVC_HDMI_AviInfoFrame_ActiveFormatToStr(
445        BAVC_HDMI_AviInfoFrame_ActiveInfo uiA0)
446{
447        uint8_t entries ;
448       
449        entries =
450                sizeof(BAVC_HDMI_AviInfoFrame_Text_A0) /
451                sizeof(*BAVC_HDMI_AviInfoFrame_Text_A0) ;
452               
453        if (uiA0 < entries)
454                return BAVC_HDMI_AviInfoFrame_Text_A0[uiA0] ;
455        else
456                return EnumError ;
457}
458
459
460/******************************************************************************
461Summary:
462Return character string for Bar Info (B1B0) enumeration
463*******************************************************************************/
464const char * BAVC_HDMI_AviInfoFrame_BarInfoToStr(
465        BAVC_HDMI_AviInfoFrame_BarInfo uiB1B0)
466{
467        uint8_t entries ;
468       
469        entries=
470                sizeof(BAVC_HDMI_AviInfoFrame_Text_B1B0) /
471                sizeof(*BAVC_HDMI_AviInfoFrame_Text_B1B0) ;
472       
473        if (uiB1B0 < entries)
474                return BAVC_HDMI_AviInfoFrame_Text_B1B0[uiB1B0] ;
475        else
476                return EnumError;
477}
478
479
480/******************************************************************************
481Summary:
482Return character string for Scan Information (S1S0) enumeration
483*******************************************************************************/
484const char * BAVC_HDMI_AviInfoFrame_ScanInfoToStr(
485        BAVC_HDMI_AviInfoFrame_ScanInfo uiS1S0)
486{
487        uint8_t entries ;
488       
489        entries=
490                sizeof(BAVC_HDMI_AviInfoFrame_Text_S1S0) /
491                sizeof(*BAVC_HDMI_AviInfoFrame_Text_S1S0) ;
492               
493        if (uiS1S0 < entries)
494                return BAVC_HDMI_AviInfoFrame_Text_S1S0[uiS1S0] ;
495        else
496                return EnumError;
497}
498
499
500/******************************************************************************
501Summary:
502Return character string for Colorimetry (C1C0) enumeration
503*******************************************************************************/
504const char * BAVC_HDMI_AviInfoFrame_ColorimetryToStr(
505        BAVC_HDMI_AviInfoFrame_Colorimetry uiC1C0)
506{
507        uint8_t entries ;
508       
509        entries=
510                sizeof(BAVC_HDMI_AviInfoFrame_Text_C1C0) /
511                sizeof(*BAVC_HDMI_AviInfoFrame_Text_C1C0) ;
512               
513        if (uiC1C0 < entries)
514                return BAVC_HDMI_AviInfoFrame_Text_C1C0[uiC1C0] ;
515        else
516                return EnumError;
517}
518
519/******************************************************************************
520Summary:
521Return character string for Picture Aspect Ratio (M1M0) enumeration
522*******************************************************************************/
523const char * BAVC_HDMI_AviInfoFrame_PictureAspectRatioToStr(
524        BAVC_HDMI_AviInfoFrame_PictureAspectRatio uiM1M0)
525{
526        uint8_t entries ;
527       
528        entries=
529                sizeof(BAVC_HDMI_AviInfoFrame_Text_M1M0) /
530                sizeof(*BAVC_HDMI_AviInfoFrame_Text_M1M0) ;
531               
532        if (uiM1M0 < entries)
533                return BAVC_HDMI_AviInfoFrame_Text_M1M0[uiM1M0] ;
534        else
535                return EnumError;
536}
537
538
539/******************************************************************************
540Summary:
541Return character string for Active Format Aspect Ratio (R3_R0) enumeration
542*******************************************************************************/
543const char * BAVC_HDMI_AviInfoFrame_ActiveFormatAspectRatioToStr(
544        BAVC_HDMI_AviInfoFrame_ActiveFormatAspectRatio uiR3_R0)
545{
546        uint8_t entries ;
547       
548        entries=
549                sizeof(BAVC_HDMI_AviInfoFrame_Text_R3_R0) /
550                sizeof(*BAVC_HDMI_AviInfoFrame_Text_R3_R0) ;
551               
552        if (uiR3_R0 < entries)
553                return BAVC_HDMI_AviInfoFrame_Text_R3_R0[uiR3_R0] ;
554        else
555                return EnumError;
556}
557
558
559/******************************************************************************
560Summary:
561Return character string for IT Content (ITC) enumeration
562*******************************************************************************/
563const char * BAVC_HDMI_AviInfoFrame_ITContentToStr(
564        BAVC_HDMI_AviInfoFrame_ITContent uiITC)
565{
566        uint8_t entries ;
567       
568        entries=
569                sizeof(BAVC_HDMI_AviInfoFrame_Text_ITC) /
570                sizeof(*BAVC_HDMI_AviInfoFrame_Text_ITC) ;
571               
572        if (uiITC < entries)
573                return BAVC_HDMI_AviInfoFrame_Text_ITC[uiITC] ;
574        else
575                return EnumError;
576}
577
578
579/******************************************************************************
580Summary:
581Return character string for Extended Colorimetry (EC2_EC0) enumeration
582*******************************************************************************/
583const char * BAVC_HDMI_AviInfoFrame_ExtendedColorimetryToStr(
584        BAVC_HDMI_AviInfoFrame_ExtendedColorimetry uiEC2_EC0)
585{
586        uint8_t entries ;
587       
588        entries=
589                sizeof(BAVC_HDMI_AviInfoFrame_Text_EC2_EC0) /
590                sizeof(*BAVC_HDMI_AviInfoFrame_Text_EC2_EC0) ;
591               
592        if (uiEC2_EC0 < entries)
593                return BAVC_HDMI_AviInfoFrame_Text_EC2_EC0[uiEC2_EC0] ;
594        else
595                return EnumError;
596}
597
598
599/******************************************************************************
600Summary:
601Return character string for RGB Quantization Range (Q1Q0) enumeration
602*******************************************************************************/
603const char * BAVC_HDMI_AviInfoFrame_RGBQuantizationRangeToStr(
604        BAVC_HDMI_AviInfoFrame_RGBQuantizationRange uiQ1Q0)
605{
606        uint8_t entries ;
607       
608        entries=
609                sizeof(BAVC_HDMI_AviInfoFrame_Text_Q1Q0) /
610                sizeof(*BAVC_HDMI_AviInfoFrame_Text_Q1Q0) ;
611               
612        if (uiQ1Q0 < entries)
613                return BAVC_HDMI_AviInfoFrame_Text_Q1Q0[uiQ1Q0] ;
614        else
615                return EnumError;
616}
617
618
619/******************************************************************************
620Summary:
621Return character string for Scaling (SC1SC0) enumeration
622*******************************************************************************/
623const char * BAVC_HDMI_AviInfoFrame_ScalingToStr(
624        BAVC_HDMI_AviInfoFrame_Scaling uiSC1SC0)
625{
626        uint8_t entries ;
627       
628        entries=
629                sizeof(BAVC_HDMI_AviInfoFrame_Text_SC1SC0) /
630                sizeof(*BAVC_HDMI_AviInfoFrame_Text_SC1SC0) ;
631               
632        if (uiSC1SC0 < entries)
633                return BAVC_HDMI_AviInfoFrame_Text_SC1SC0[uiSC1SC0] ;
634        else
635                return EnumError;
636}
637
638
639/******************************************************************************
640Summary:
641Return character string for Video ID Code (VIC) enumeration
642*******************************************************************************/
643const char * BAVC_HDMI_AviInfoFrame_VideoIdCodeToStr(
644        BAVC_HDMI_AviInfoFrame_Scaling uiVIC)
645{
646        uint8_t entries ;
647       
648        entries=
649                sizeof(BAVC_HDMI_AviInfoFrame_Text_VIC) /
650                sizeof(*BAVC_HDMI_AviInfoFrame_Text_VIC) ;
651               
652        if (uiVIC < entries)
653                return BAVC_HDMI_AviInfoFrame_Text_VIC[uiVIC] ;
654        else
655                return EnumError;
656}
657
658
659
660/******************************************************************************
661Summary:
662Return character string for IT Content Type enumeration
663*******************************************************************************/
664const char * BAVC_HDMI_AviInfoFrame_ContentTypeToStr(
665        BAVC_HDMI_AviInfoFrame_ContentType eContentType)
666{
667        uint8_t entries ;
668       
669        entries=
670                sizeof(BAVC_HDMI_AviInfoFrame_Text_CN1CN0) /
671                sizeof(*BAVC_HDMI_AviInfoFrame_Text_CN1CN0) ;
672               
673        if (eContentType < entries)
674                return BAVC_HDMI_AviInfoFrame_Text_CN1CN0[eContentType] ;
675        else
676                return EnumError;
677}
678
679
680/******************************************************************************
681Summary:
682Return character string for Ycc Quantization Range enumeration
683*******************************************************************************/
684const char * BAVC_HDMI_AviInfoFrame_YccQuantizationRangeToStr(
685        BAVC_HDMI_AviInfoFrame_ContentType eYccQuantizationRange)
686{
687        uint8_t entries ;
688       
689        entries=
690                sizeof(BAVC_HDMI_AviInfoFrame_Text_YQ1YQ0) /
691                sizeof(*BAVC_HDMI_AviInfoFrame_Text_YQ1YQ0) ;
692               
693        if (eYccQuantizationRange < entries)
694                return BAVC_HDMI_AviInfoFrame_Text_YQ1YQ0[eYccQuantizationRange] ;
695        else
696                return EnumError;
697}
698
699
700/******************************************************************************
701Summary:
702Return character string for Audio Coding Type (CT3_CT0) enumeration
703*******************************************************************************/
704const char * BAVC_HDMI_AudioInfoFrame_CodingTypeToStr(
705        BAVC_HDMI_AudioInfoFrame_CodingType uiCT3_CT0)
706{
707        uint8_t entries ;
708       
709        entries=
710                sizeof(BAVC_HDMI_AudioInfoFrame_Text_CT3_CT0) /
711                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_CT3_CT0) ;
712               
713        if (uiCT3_CT0 < entries)
714                return BAVC_HDMI_AudioInfoFrame_Text_CT3_CT0[uiCT3_CT0] ;
715        else
716                return EnumError;
717}
718
719/******************************************************************************
720Summary:
721Return character string for Audio Channel Count (CC2_CC0) enumeration
722*******************************************************************************/
723const char * BAVC_HDMI_AudioInfoFrame_ChannelCountToStr(
724        BAVC_HDMI_AudioInfoFrame_ChannelCount uiCC2_CC0)
725{
726        uint8_t entries ;
727       
728        entries=
729                sizeof(BAVC_HDMI_AudioInfoFrame_Text_CC2_CC0) /
730                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_CC2_CC0) ;
731               
732        if (uiCC2_CC0 < entries)
733                return BAVC_HDMI_AudioInfoFrame_Text_CC2_CC0[uiCC2_CC0] ;
734        else
735                return EnumError;
736}
737
738
739/******************************************************************************
740Summary:
741Return character string for Sampling Frequency (SF2_SF0) enumeration
742*******************************************************************************/
743const char * BAVC_HDMI_AudioInfoFrame_SampleFrequencyToStr(
744        BAVC_HDMI_AudioInfoFrame_SampleFrequency uiSF2_SF0)
745{
746        uint8_t entries ;
747       
748        entries=
749                sizeof(BAVC_HDMI_AudioInfoFrame_Text_SF2_SF0) /
750                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_SF2_SF0) ;
751               
752        if (uiSF2_SF0 < entries)
753                return BAVC_HDMI_AudioInfoFrame_Text_SF2_SF0[uiSF2_SF0] ;
754        else
755                return EnumError;
756}
757
758
759/******************************************************************************
760Summary:
761Return character string for Sample Size (SS1SS0) enumeration
762*******************************************************************************/
763const char * BAVC_HDMI_AudioInfoFrame_SampleSizeToStr(
764        BAVC_HDMI_AudioInfoFrame_SampleSize uiSS1SS0)
765{
766        uint8_t entries ;
767       
768        entries=
769                sizeof(BAVC_HDMI_AudioInfoFrame_Text_SS1SS0) /
770                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_SS1SS0) ;
771               
772        if (uiSS1SS0 < entries)
773                return BAVC_HDMI_AudioInfoFrame_Text_SS1SS0[uiSS1SS0] ;
774        else
775                return EnumError;
776}
777
778
779/******************************************************************************
780Summary:
781Return character string for Level Shift Values (LSV3_LSV0) enumeration
782*******************************************************************************/
783const char * BAVC_HDMI_AudioInfoFrame_LevelShiftToStr(
784        BAVC_HDMI_AudioInfoFrame_LevelShift uiLSV3_LSV0)
785{
786        uint8_t entries ;
787       
788        entries=
789                sizeof(BAVC_HDMI_AudioInfoFrame_Text_LSV3_LSV0) /
790                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_LSV3_LSV0) ;
791               
792        if (uiLSV3_LSV0 < entries)
793                return BAVC_HDMI_AudioInfoFrame_Text_LSV3_LSV0[uiLSV3_LSV0] ;
794        else
795                return EnumError;
796}
797
798
799/******************************************************************************
800Summary:
801Return character string for Colorspace (DM) enumeration
802*******************************************************************************/
803const char * BAVC_HDMI_AudioInfoFrame_DownMixInhibitToStr(
804        BAVC_HDMI_AudioInfoFrame_DownMixInhibit uiDM)
805{
806        uint8_t entries ;
807       
808        entries=
809                sizeof(BAVC_HDMI_AudioInfoFrame_Text_DM) /
810                sizeof(*BAVC_HDMI_AudioInfoFrame_Text_DM) ;
811               
812        if (uiDM < entries)
813                return BAVC_HDMI_AudioInfoFrame_Text_DM[uiDM] ;
814        else
815                return EnumError;
816}
817
818
819
820#if BAVC_HDMI_RECEIVER
821/***************************************************************************
822Summary:
823        Get Color Matrix based on CEA 861 AviInfoFrame information
824***************************************************************************/
825uint8_t BAVC_HDMI_AviInfoFrameToColorMatrix(
826        BAVC_HDMI_AviInfoFrame *pAviInfoFrame,
827        uint8_t uiVideoIdCode)
828{
829    BAVC_HDMI_AviInfoFrame_VideoFormat eAviInfoFrameFormat ;
830    bool limitedRange ;
831    BAVC_CscMode     cscMode ;
832
833    BSTD_UNUSED(uiVideoIdCode) ;
834       
835
836    /* set the color matrix */
837    if (pAviInfoFrame->VideoIdCode == 0 )
838        /* IT FORMAT */
839        eAviInfoFrameFormat = BAVC_HDMI_AviInfoFrame_VideoFormat_eIT ;
840   
841    else if (((pAviInfoFrame->VideoIdCode >=  2) && (pAviInfoFrame->VideoIdCode <=  3))
842    || ((pAviInfoFrame->VideoIdCode >=  6) && (pAviInfoFrame->VideoIdCode <= 15))
843    || ((pAviInfoFrame->VideoIdCode >= 17) && (pAviInfoFrame->VideoIdCode <= 18))
844    || ((pAviInfoFrame->VideoIdCode >= 21) && (pAviInfoFrame->VideoIdCode <= 30))
845    || ((pAviInfoFrame->VideoIdCode >= 35) && (pAviInfoFrame->VideoIdCode <= 38))
846    || ((pAviInfoFrame->VideoIdCode >= 42) && (pAviInfoFrame->VideoIdCode <= 45))
847    || ((pAviInfoFrame->VideoIdCode >= 48) && (pAviInfoFrame->VideoIdCode <= 50)))
848            /* SD FORMAT */
849            eAviInfoFrameFormat = BAVC_HDMI_AviInfoFrame_VideoFormat_eSD ;
850   
851    else if (((pAviInfoFrame->VideoIdCode >=  4) && (pAviInfoFrame->VideoIdCode <=  5))
852    || ((pAviInfoFrame->VideoIdCode ==  16))
853    || ((pAviInfoFrame->VideoIdCode >=  19) && (pAviInfoFrame->VideoIdCode <= 20))
854    || ((pAviInfoFrame->VideoIdCode >=  31) && (pAviInfoFrame->VideoIdCode <= 34))
855    || ((pAviInfoFrame->VideoIdCode >=  39) && (pAviInfoFrame->VideoIdCode <= 41))
856    || ((pAviInfoFrame->VideoIdCode >=  46) && (pAviInfoFrame->VideoIdCode <= 47)))
857            /* HD FORMAT */
858            eAviInfoFrameFormat = BAVC_HDMI_AviInfoFrame_VideoFormat_eHD ;
859   
860    else 
861    {
862        /* New/Unknown Format */
863        BDBG_WRN(("Unknown/Unsupported VIDEO ID Code %d; Assuming HD format", 
864                        pAviInfoFrame->VideoIdCode)) ;
865            eAviInfoFrameFormat = BAVC_HDMI_AviInfoFrame_VideoFormat_eHD ;
866    }
867
868   
869    /* YCbCr */
870    if ((pAviInfoFrame->ePixelEncoding == BAVC_HDMI_AviInfoFrame_Colorspace_eYCbCr422) 
871    || (pAviInfoFrame->ePixelEncoding == BAVC_HDMI_AviInfoFrame_Colorspace_eYCbCr444))
872    {
873        /* Unspecified colorimetry, but SD Format */
874        if (((pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eNoData)
875        && (eAviInfoFrameFormat == BAVC_HDMI_AviInfoFrame_VideoFormat_eSD))
876       
877        /* OR Colorimetry is specified as BT.601 */
878        || (pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eSmpte170)
879       
880        /* OR Colorimetry is specified as  xvYCC601 */
881        || ((pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eExtended)
882        && (pAviInfoFrame->eExtendedColorimetry == BAVC_HDMI_AviInfoFrame_ExtendedColorimetry_exvYCC601)))
883        { 
884            /* Set the BT.601 YCbCr flag */
885             cscMode = BAVC_CscMode_e601YCbCr ;
886        }
887        else
888        {     
889            /* Set the BT.709 YCbCr flag */
890            cscMode = BAVC_CscMode_e709YCbCr ;
891          }
892    }
893    /****** RGB ******/
894    else if (pAviInfoFrame->ePixelEncoding == BAVC_HDMI_AviInfoFrame_Colorspace_eRGB) 
895    {
896        /* determine whether color range limited vs full */
897       
898        /* if xv.Color (always scaled as limited range) */                     
899        /* if ((C=3) Or (Q=1) Or  ((Q=0) And (FormatIsSD Or FormatIsHD)))                */
900               
901        if ((pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eExtended)
902               
903        /* OR limited range is expressly specified */
904        ||  (pAviInfoFrame->eRGBQuantizationRange == BAVC_HDMI_AviInfoFrame_RGBQuantizationRange_eLimitedRange) 
905             
906        /* OR video format is used to select */
907        ||  ((pAviInfoFrame->eRGBQuantizationRange == BAVC_HDMI_AviInfoFrame_RGBQuantizationRange_eDefault) 
908        &&    ((eAviInfoFrameFormat == BAVC_HDMI_AviInfoFrame_VideoFormat_eSD)
909        || (eAviInfoFrameFormat == BAVC_HDMI_AviInfoFrame_VideoFormat_eHD))))
910        { 
911            limitedRange = true ;
912#if 0                   
913           if (rgbQuantization == BAVC_HDMI_AviInfoFrame_RGBQuantizationRange_eDefault)
914               limitedRange = false ;
915#endif             
916        }
917        else
918        { 
919            limitedRange = false ;
920        }
921   
922   
923        /* NOW determine which colorimetry */
924       
925        /* Unspecified Colorimetry, but SD Format */
926        if (((pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eNoData)
927        && (eAviInfoFrameFormat == BAVC_HDMI_AviInfoFrame_VideoFormat_eSD))
928   
929        /* OR Colorimetry is specified as BT.601 */
930        || (pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eSmpte170)
931       
932        /* OR Colorimetry is specified as  xvYCC601 */
933        || ((pAviInfoFrame->eColorimetry == BAVC_HDMI_AviInfoFrame_Colorimetry_eExtended)
934        && (pAviInfoFrame->eExtendedColorimetry == BAVC_HDMI_AviInfoFrame_ExtendedColorimetry_exvYCC601)))
935        {     
936            if (limitedRange)
937                /****** BT.601 LIMITED ******/
938                cscMode = BAVC_CscMode_e601RgbLimitedRange ;
939            else
940   
941                /****** BT.601 FULL  ******/                   
942                cscMode = BAVC_CscMode_e601RgbFullRange ;
943            }
944            else
945            {
946                if (limitedRange)
947                    /****** BT.709 LIMITED ******/
948                    cscMode = BAVC_CscMode_e709RgbLimitedRange ;
949                else
950                    /****** BT.709 FULL  ******/
951                    cscMode = BAVC_CscMode_e709RgbFullRange ;
952            }
953        }
954       
955        return 0 ;
956}
957#endif
958
959/******************************************************************************
960Summary:
961Return character string for HDMI Packet Type
962*******************************************************************************/
963const char * BAVC_HDMI_PacketTypeToStr(
964        BAVC_HDMI_PacketType ePacketType)
965{
966        uint8_t entries, i ;
967
968
969        entries =
970                sizeof(PacketTypes_Text) /
971                sizeof(*PacketTypes_Text) ;
972
973        for (i = 0 ; i < entries; i++)
974        {
975                if (ePacketType == PacketTypes_Text[i].ePacketType)
976                        return PacketTypes_Text[i].PacketName;
977        }
978        return BAVC_HDMI_P_PacketTypeUnknown ;
979}
980
981
982/******************************************************************************
983Summary:
984Return character string for SPD Device Type enumeration
985*******************************************************************************/
986const char * BAVC_HDMI_SpdInfoFrame_SourceTypeToStr(
987        BAVC_HDMI_SpdInfoFrame_SourceType eSourceType)
988{
989        uint8_t entries ;
990       
991        entries=
992                sizeof(BAVC_HDMI_SpdInfoFrame_Text_SourceType) /
993                sizeof(*BAVC_HDMI_SpdInfoFrame_Text_SourceType) ;
994               
995        if (eSourceType < entries)
996                return BAVC_HDMI_SpdInfoFrame_Text_SourceType[eSourceType] ;
997        else
998                return Reserved ;
999}
1000
1001
1002/******************************************************************************
1003Summary:
1004Return character string for VS Hdmi Video Format  enumeration
1005*******************************************************************************/
1006const char * BAVC_HDMI_VsInfoFrame_HdmiVideoFormatToStr(
1007        BAVC_HDMI_VSInfoFrame_HDMIVideoFormat eFormatType)
1008{
1009        uint8_t entries ;
1010       
1011        entries=
1012                sizeof(BAVC_HDMI_VsInfoFrame_Text_HdmiVideoFormat       ) /
1013                sizeof(*BAVC_HDMI_VsInfoFrame_Text_HdmiVideoFormat) ;
1014               
1015        if (eFormatType < entries)
1016                return BAVC_HDMI_VsInfoFrame_Text_HdmiVideoFormat[eFormatType] ;
1017        else
1018                return Reserved ;
1019}
1020
1021/******************************************************************************
1022Summary:
1023Return character string for VS 3D Structure   
1024******************************************************************************/
1025const char * BAVC_HDMI_VsInfoFrame_3DStructureToStr(
1026        BAVC_HDMI_VSInfoFrame_3DStructure e3DStructure)
1027{
1028        uint8_t entries ;
1029       
1030        entries =
1031                sizeof(BAVC_HDMI_VsInfoFrame_Text_3DStructure) /
1032                sizeof(*BAVC_HDMI_VsInfoFrame_Text_3DStructure) ;
1033       
1034        if (e3DStructure < entries)
1035                return BAVC_HDMI_VsInfoFrame_Text_3DStructure[e3DStructure] ;
1036        else
1037                return Reserved ;
1038}
1039
1040
1041/******************************************************************************
1042Summary:
1043Return character string for VS 3D Ext Data enumeration
1044*******************************************************************************/
1045const char * BAVC_HDMI_VsInfoFrame_3DExtDataToStr(
1046        BAVC_HDMI_VSInfoFrame_3DExtData e3DExtType)
1047{
1048        uint8_t entries ;
1049       
1050        entries =
1051                sizeof(BAVC_HDMI_VsInfoFrame_Text_3DExtData) /
1052                sizeof(*BAVC_HDMI_VsInfoFrame_Text_3DExtData) ;
1053               
1054        if (e3DExtType < entries)
1055                return BAVC_HDMI_VsInfoFrame_Text_3DExtData[e3DExtType] ;
1056        else
1057                return Reserved ;
1058}
1059
1060
1061/******************************************************************************
1062Summary:
1063Return character string for VS 3D Ext Data enumeration
1064*******************************************************************************/
1065const char * BAVC_HDMI_VsInfoFrame_HdmiVicToStr(
1066        BAVC_HDMI_VSInfoFrame_HDMIVIC  eHdmiVic)
1067{
1068        uint8_t entries ;
1069       
1070        entries=
1071                sizeof(BAVC_HDMI_VsInfoFrame_Text_HDMIVIC) /
1072                sizeof(*BAVC_HDMI_VsInfoFrame_Text_HDMIVIC) ;
1073               
1074        if (eHdmiVic < entries)
1075                return BAVC_HDMI_VsInfoFrame_Text_HDMIVIC[eHdmiVic] ;
1076        else
1077                return Reserved ;
1078}
1079
1080
1081/******************************************************************************
1082unsigned int BAVC_HDMI_HDCP_NumberOfSetBits
1083Summary: Get the number of Set Bits
1084*******************************************************************************/
1085unsigned int BAVC_HDMI_HDCP_NumberOfSetBits(const unsigned char *bytes, int nbytes)
1086{
1087        int i, j ;
1088        int bit ;
1089        int count = 0 ;
1090        uint8_t byteToCheck;
1091
1092        count = 0 ;
1093        for (i = 0; i < nbytes; i++)
1094        {
1095                bit = 1 ;
1096                byteToCheck = bytes[i];
1097                for (j = 0; j < 8 ; j++)
1098                {
1099                        if (bit & byteToCheck)
1100                                count++ ;
1101                        bit = bit << 1 ;
1102                }
1103        }
1104        return count ;
1105} /* end BAVC_HDMI_HDCP_NumberOfSetBits */
1106
1107
Note: See TracBrowser for help on using the repository browser.