Index: helix-libs/clientapps/clutter/LICENSE.txt =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/LICENSE.txt 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,30 @@ + Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + + The contents of this directory, and (except where otherwise + indicated) the directories included within this directory, are + subject to the current version of the RealNetworks Public Source + License (the "RPSL") available at RPSL.txt in this directory, unless + you have licensed the directory under the current version of the + RealNetworks Community Source License (the "RCSL") available at + RCSL.txt in this directory, in which case the RCSL will apply. You + may also obtain the license terms directly from RealNetworks. You + may not use the files in this directory except in compliance with the + RPSL or, if you have a valid RCSL with RealNetworks applicable to + this directory, the RCSL. Please see the applicable RPSL or RCSL for + the rights, obligations and limitations governing use of the contents + of the directory. + + This directory is part of the Helix DNA Technology. RealNetworks is + the developer of the Original Code and owns the copyrights in the + portions it created. + + This directory, and the directories included with this directory, are + distributed and made available on an 'AS IS' basis, WITHOUT WARRANTY + OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY + DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY + WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, + QUIET ENJOYMENT OR NON-INFRINGEMENT. + + Technology Compatibility Kit Test Suite(s) Location: + http://www.helixcommunity.org/content/tck + Index: helix-libs/clientapps/clutter/RCSL.txt =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/RCSL.txt 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,948 @@ +The RCSL is made up of a base agreement and a few Attachments. + +For Research and Development use, you agree to the terms of the +RCSL R&D License (base RCSL and Attachments A, B, and C) + +For Commercial Use (either distribution or internal commercial +deployment) of the Helix DNA with or without support for RealNetworks' +RealAudio and RealVideo Add-on Technology, you agree to the +terms of the same RCSL R&D license +and execute one or more additional Commercial Use License attachments +. + +------------------------------------------------------------------------ + + + REALNETWORKS COMMUNITY SOURCE LICENSE + +Version 1.2 (Rev. Date: January 22, 2003). + + + RECITALS + +Original Contributor has developed Specifications, Source Code +implementations and Executables of certain Technology; and + +Original Contributor desires to license the Technology to a large +community to facilitate research, innovation and product development +while maintaining compatibility of such products with the Technology as +delivered by Original Contributor; and + +Original Contributor desires to license certain Trademarks for the +purpose of branding products that are compatible with the relevant +Technology delivered by Original Contributor; and + +You desire to license the Technology and possibly certain Trademarks +from Original Contributor on the terms and conditions specified in this +License. + +In consideration for the mutual covenants contained herein, You and +Original Contributor agree as follows: + + + AGREEMENT + +*1. Introduction.* + +The RealNetworks Community Source License ("RCSL") and effective +attachments ("License") may include five distinct licenses: + +i) Research Use license -- License plus Attachments A, B and C only. + +ii) Commercial Use and Trademark License, which may be for Internal +Deployment Use or external distribution, or both -- License plus +Attachments A, B, C, and D. + +iii) Technology Compatibility Kit (TCK) license -- Attachment C. + +iv) Add-On Technology License (Executable) Commercial Use License +-Attachment F. + +v) Add-On Technology Source Code Porting and Optimization +License-Attachment G. + +The Research Use license is effective when You click and accept this +License. The TCK is effective when You click and accept this License, +unless otherwise specified in the TCK attachments. The Commercial Use +and Trademark, Add-On Technology License, and the Add-On Technology +Source Code Porting and Optimization licenses must each be signed by You +and Original Contributor to become effective. Once effective, these +licenses and the associated requirements and responsibilities are +cumulative. Capitalized terms used in this License are defined in the +Glossary. + +*2. License Grants.* + +2.1 Original Contributor Grant. + +Subject to Your compliance with Sections 3, 8.10 and Attachment A of +this License, Original Contributor grants to You a worldwide, +royalty-free, non-exclusive license, to the extent of Original +Contributor's Intellectual Property Rights covering the Original Code, +Upgraded Code and Specifications, to do the following: + +(a) Research Use License: + +(i) use, reproduce and modify the Original Code, Upgraded Code and +Specifications to create Modifications and Reformatted Specifications +for Research Use by You; + +(ii) publish and display Original Code, Upgraded Code and Specifications +with, or as part of Modifications, as permitted under Section 3.1(b) below; + +(iii) reproduce and distribute copies of Original Code and Upgraded Code +to Licensees and students for Research Use by You; + +(iv) compile, reproduce and distribute Original Code and Upgraded Code +in Executable form, and Reformatted Specifications to anyone for +Research Use by You. + +(b) Other than the licenses expressly granted in this License, Original +Contributor retains all right, title, and interest in Original Code and +Upgraded Code and Specifications. + +2.2 Your Grants. + +(a) To Other Licensees. You hereby grant to each Licensee a license to +Your Error Corrections and Shared Modifications, of the same scope and +extent as Original Contributor's licenses under Section 2.1 a) above +relative to Research Use and Attachment D relative to Commercial Use. + +(b) To Original Contributor. You hereby grant to Original Contributor a +worldwide, royalty-free, non-exclusive, perpetual and irrevocable +license, to the extent of Your Intellectual Property Rights covering +Your Error Corrections, Shared Modifications and Reformatted +Specifications, to use, reproduce, modify, display and distribute Your +Error Corrections, Shared Modifications and Reformatted Specifications, +in any form, including the right to sublicense such rights through +multiple tiers of distribution. + +(c) Other than the licenses expressly granted in Sections 2.2(a) and (b) +above, and the restrictions set forth in Section 3.1(d)(iv) below, You +retain all right, title, and interest in Your Error Corrections, Shared +Modifications and Reformatted Specifications. + +2.3 Contributor Modifications. + +You may use, reproduce, modify, display and distribute Contributor Error +Corrections, Shared Modifications and Reformatted Specifications, +obtained by You under this License, to the same scope and extent as with +Original Code, Upgraded Code and Specifications. + +2.4 Subcontracting. + +You may deliver the Source Code of Covered Code to other Licensees +having at least a Research Use license, for the sole purpose of +furnishing development services to You in connection with Your rights +granted in this License. All such Licensees must execute appropriate +documents with respect to such work consistent with the terms of this +License, and acknowledging their work-made-for-hire status or assigning +exclusive right to the work product and associated Intellectual Property +Rights to You. + +*3. Requirements and Responsibilities*. + +3.1 Research Use License. + +As a condition of exercising the rights granted under Section 2.1(a) +above, You agree to comply with the following: + +(a) Your Contribution to the Community. All Error Corrections and Shared +Modifications which You create or contribute to are automatically +subject to the licenses granted under Section 2.2 above. You are +encouraged to license all of Your other Modifications under Section 2.2 +as Shared Modifications, but are not required to do so. You agree to +notify Original Contributor of any errors in the Specification. + +(b) Source Code Availability. You agree to provide all Your Error +Corrections to Original Contributor as soon as reasonably practicable +and, in any event, prior to Internal Deployment Use or Commercial Use, +if applicable. Original Contributor may, at its discretion, post Source +Code for Your Error Corrections and Shared Modifications on the +Community Webserver. You may also post Error Corrections and Shared +Modifications on a web-server of Your choice; provided, that You must +take reasonable precautions to ensure that only Licensees have access to +such Error Corrections and Shared Modifications. Such precautions shall +include, without limitation, a password protection scheme limited to +Licensees and a click-on, download certification of Licensee status +required of those attempting to download from the server. An example of +an acceptable certification is attached as Attachment A-2. + +(c) Notices. All Error Corrections and Shared Modifications You create +or contribute to must include a file documenting the additions and +changes You made and the date of such additions and changes. You must +also include the notice set forth in Attachment A-1 in the file header. +If it is not possible to put the notice in a particular Source Code file +due to its structure, then You must include the notice in a location +(such as a relevant directory file), where a recipient would be most +likely to look for such a notice. + +(d) Redistribution. + +(i) Source. Covered Code may be distributed in Source Code form only to +another Licensee (except for students as provided below). You may not +offer or impose any terms on any Covered Code that alter the rights, +requirements, or responsibilities of such Licensee. You may distribute +Covered Code to students for use in connection with their course work +and research projects undertaken at accredited educational institutions. +Such students need not be Licensees, but must be given a copy of the +notice set forth in Attachment A-3 and such notice must also be included +in a file header or prominent location in the Source Code made available +to such students. + +(ii) Executable. You may distribute Executable version(s) of Covered +Code to Licensees and other third parties only for the purpose of +evaluation and comment in connection with Research Use by You and under +a license of Your choice, but which limits use of such Executable +version(s) of Covered Code only to that purpose. + +(iii) Modified Class, Interface and Package Naming. In connection with +Research Use by You only, You may use Original Contributor's class, +Interface and package names only to accurately reference or invoke the +Source Code files You modify. Original Contributor grants to You a +limited license to the extent necessary for such purposes. + +(iv) You expressly agree that any distribution, in whole or in part, of +Modifications developed by You shall only be done pursuant to the terms +and conditions of this License. + +(e) Extensions. + +(i) Covered Code. You may not include any Source Code of Community Code +in any Extensions. You may include the compiled Header Files of +Community Code in an Extension provided that Your use of the Covered +Code, including Heading Files, complies with the Commercial Use License, +the TCK and all other terms of this License. + +(ii) Publication. No later than the date on which You first distribute +such Extension for Commercial Use, You must publish to the industry, on +a non-confidential basis and free of all copyright restrictions with +respect to reproduction and use, an accurate and current specification +for any Extension. In addition, You must make available an appropriate +test suite, pursuant to the same rights as the specification, +sufficiently detailed to allow any third party reasonably skilled in the +technology to produce implementations of the Extension compatible with +the specification. Such test suites must be made available as soon as +reasonably practicable but, in no event, later than ninety (90) days +after Your first Commercial Use of the Extension. You must use +reasonable efforts to promptly clarify and correct the specification and +the test suite upon written request by Original Contributor. + +(iii) Open. You agree to refrain from enforcing any Intellectual +Property Rights You may have covering any interface(s) of Your +Extension, which would prevent the implementation of such interface(s) +by Original Contributor or any Licensee. This obligation does not +prevent You from enforcing any Intellectual Property Right You have that +would otherwise be infringed by an implementation of Your Extension. + +(iv) Interface Modifications and Naming. You may not modify or add to +the GUID space * * "xxxxxxxx-0901-11d1-8B06-00A024406D59" or any other +GUID space designated by Original Contributor. You may not modify any +Interface prefix provided with the Covered Code or any other prefix +designated by Original Contributor.* * + +* * + +(f) You agree that any Specifications provided to You by Original +Contributor are confidential and proprietary information of Original +Contributor. You must maintain the confidentiality of the Specifications +and may not disclose them to any third party without Original +Contributor's prior written consent. You may only use the Specifications +under the terms of this License and only for the purpose of implementing +the terms of this License with respect to Covered Code. You agree not +use, copy or distribute any such Specifications except as provided in +writing by Original Contributor. + +3.2 Commercial Use License. + +You may not make Commercial Use of any Covered Code unless You and +Original Contributor have executed a copy of the Commercial Use and +Trademark License attached as Attachment D. + +*4. Versions of the License.* + +4.1 License Versions. + +Original Contributor may publish revised versions of the License from +time to time. Each version will be given a distinguishing version number. + +4.2 Effect. + +Once a particular version of Covered Code has been provided under a +version of the License, You may always continue to use such Covered Code +under the terms of that version of the License. You may also choose to +use such Covered Code under the terms of any subsequent version of the +License. No one other than Original Contributor has the right to +promulgate License versions. + +4.3 Multiple-Licensed Code. + +Original Contributor may designate portions of the Covered Code as +"Multiple-Licensed." "Multiple-Licensed" means that the Original +Contributor permits You to utilize those designated portions of the +Covered Code under Your choice of this License or the alternative +license(s), if any, specified by the Original Contributor in an +Attachment to this License. + +*5. Disclaimer of Warranty.* + +5.1 COVERED CODE PROVIDED AS IS. + +COVERED CODE IS PROVIDED UNDER THIS LICENSE "AS IS," WITHOUT WARRANTY OF +ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, +WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT +FOR A PARTICULAR PURPOSE OR NON-INFRINGING. YOU AGREE TO BEAR THE ENTIRE +RISK IN CONNECTION WITH YOUR USE AND DISTRIBUTION OF COVERED CODE UNDER +THIS LICENSE. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART +OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER +EXCEPT SUBJECT TO THIS DISCLAIMER. + +5.2 Not Designed for High Risk Activities. + +You acknowledge that Original Code, Upgraded Code and Specifications are +not designed or intended for use in high risk activities including, but +not limited to: (i) on-line control of aircraft, air traffic, aircraft +navigation or aircraft communications; or (ii) in the design, +construction, operation or maintenance of any nuclear facility. Original +Contributor disclaims any express or implied warranty of fitness for +such uses. + +*6. Termination.* + +6.1 By You. + +You may terminate this Research Use license at anytime by providing +written notice to Original Contributor. + +6.2 By Original Contributor. + +This License and the rights granted hereunder will terminate: + +(i) automatically if You fail to comply with the terms of this License +and fail to cure such breach within 30 days of receipt of written notice +of the breach; + +(ii) immediately in the event of circumstances specified in Sections 7.1 +and 8.4; or + +(iii) at Original Contributor's discretion upon any action initiated by +You (including by cross-claim or counter claim) alleging that use or +distribution by Original Contributor or any Licensee, of Original Code, +Upgraded Code, Error Corrections, Shared Modifications or Specifications +infringe a patent owned or controlled by You. + +6.3 Effective of Termination. + +Upon termination, You agree to discontinue use of and destroy all copies +of Covered Code in Your possession. All sublicenses to the Covered Code +which You have properly granted shall survive any termination of this +License. Provisions that, by their nature, should remain in effect +beyond the termination of this License shall survive including, without +limitation, Sections 2.2, 3, 5, 7 and 8. + +6.4 No Compensation. + +Each party waives and releases the other from any claim to compensation +or indemnity for permitted or lawful termination of the business +relationship established by this License. + +*7. Liability.* + +7.1 Infringement. Should any of the Original Code, Upgraded Code, TCK or +Specifications ("Materials") become the subject of a claim of +infringement, Original Contributor may, at its sole option, (i) attempt +to procure the rights necessary for You to continue using the Materials, +(ii) modify the Materials so that they are no longer infringing, or +(iii) terminate Your right to use the Materials, immediately upon +written notice, and refund to You the amount, if any, having then +actually been paid by You to Original Contributor for the Original Code, +Upgraded Code and TCK, depreciated on a straight line, five year basis. + +7.2 LIMITATION OF LIABILITY. TO THE FULL EXTENT ALLOWED BY APPLICABLE +LAW, ORIGINAL CONTRIBUTOR'S LIABILITY TO YOU FOR CLAIMS RELATING TO THIS +LICENSE, WHETHER FOR BREACH OR IN TORT, SHALL BE LIMITED TO ONE HUNDRED +PERCENT (100%) OF THE AMOUNT HAVING THEN ACTUALLY BEEN PAID BY YOU TO +ORIGINAL CONTRIBUTOR FOR ALL COPIES LICENSED HEREUNDER OF THE PARTICULAR +ITEMS GIVING RISE TO SUCH CLAIM, IF ANY, DURING THE TWELVE MONTHS +PRECEDING THE CLAIMED BREACH. IN NO EVENT WILL YOU (RELATIVE TO YOUR +SHARED MODIFICATIONS OR ERROR CORRECTIONS) OR ORIGINAL CONTRIBUTOR BE +LIABLE FOR ANY INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL +DAMAGES IN CONNECTION WITH OR RISING OUT OF THIS LICENSE (INCLUDING, +WITHOUT LIMITATION, LOSS OF PROFITS, USE, DATA, OR OTHER ECONOMIC +ADVANTAGE), HOWEVER IT ARISES AND ON ANY THEORY OF LIABILITY, WHETHER IN +AN ACTION FOR CONTRACT, STRICT LIABILITY OR TORT (INCLUDING NEGLIGENCE) +OR OTHERWISE, WHETHER OR NOT YOU OR ORIGINAL CONTRIBUTOR HAS BEEN +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE AND NOTWITHSTANDING THE +FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. + +*8. Miscellaneous.* + +8.1 Trademark. + +You shall not use any Trademark unless You and Original Contributor +execute a copy of the Commercial Use and Trademark License Agreement +attached hereto as Attachment D. Except as expressly provided in the +License, You are granted no right, title or license to, or interest in, +any Trademarks. Whether or not You and Original Contributor enter into +the Trademark License, You agree not to (i) challenge Original +Contributor's ownership or use of Trademarks; (ii) attempt to register +any Trademarks, or any mark or logo substantially similar thereto; or +(iii) incorporate any Trademarks into Your own trademarks, product +names, service marks, company names, or domain names. + +8.2 Integration. + +This License represents the complete agreement concerning the subject +matter hereof. + +8.3 Assignment. + +Original Contributor may assign this License, and its rights and +obligations hereunder, in its sole discretion. You may assign the +Research Use portions of this License and the TCK license to a third +party upon prior written notice to Original Contributor (which may be +provided electronically via the Community Web-Server). You may not +assign the Commercial Use and Trademark license, the Add-On Technology +License, or the Add-On Technology Source Code Porting License, including +by way of merger (regardless of whether You are the surviving entity) or +acquisition, without Original Contributor's prior written consent. + +8.4 Severability. + +If any provision of this License is held to be unenforceable, such +provision shall be reformed only to the extent necessary to make it +enforceable. Notwithstanding the foregoing, if You are prohibited by law +from fully and specifically complying with Sections 2.2 or 3, this +License will immediately terminate and You must immediately discontinue +any use of Covered Code. + +8.5 Governing Law. + +This License shall be governed by the laws of the United States and the +State of Washington, as applied to contracts entered into and to be +performed in Washington between Washington residents. The application of +the United Nations Convention on Contracts for the International Sale of +Goods is expressly excluded. You agree that the state and federal courts +located in Seattle, Washington have exclusive jurisdiction over any +claim relating to the License, including contract and tort claims. + +8.6 Dispute Resolution. + +a) Arbitration. Any dispute arising out of or relating to this License +shall be finally settled by arbitration as set out herein, except that +either party may bring any action, in a court of competent jurisdiction +(which jurisdiction shall be exclusive), with respect to any dispute +relating to such party's Intellectual Property Rights or with respect to +Your compliance with the TCK license. Arbitration shall be administered: +(i) by the American Arbitration Association (AAA), (ii) in accordance +with the rules of the United Nations Commission on International Trade +Law (UNCITRAL) (the "Rules") in effect at the time of arbitration as +modified herein; and (iii) the arbitrator will apply the substantive +laws of Washington and the United States. Judgment upon the award +rendered by the arbitrator may be entered in any court having +jurisdiction to enforce such award. + +b) Arbitration language, venue and damages. All arbitration proceedings +shall be conducted in English by a single arbitrator selected in +accordance with the Rules, who must be fluent in English and be either a +retired judge or practicing attorney having at least ten (10) years +litigation experience and be reasonably familiar with the technology +matters relative to the dispute. Unless otherwise agreed, arbitration +venue shall be in Seattle, Washington. The arbitrator may award monetary +damages only and nothing shall preclude either party from seeking +provisional or emergency relief from a court of competent jurisdiction. +The arbitrator shall have no authority to award damages in excess of +those permitted in this License and any such award in excess is void. +All awards will be payable in U.S. dollars and may include, for the +prevailing party (i) pre-judgment award interest, (ii) reasonable +attorneys' fees incurred in connection with the arbitration, and (iii) +reasonable costs and expenses incurred in enforcing the award. The +arbitrator will order each party to produce identified documents and +respond to no more than twenty-five single question interrogatories. + +8.7 Construction. + +Any law or regulation, which provides that the language of a contract +shall be construed against the drafter, shall not apply to this License. + +8.8 U.S. Government End Users. + +The Covered Code is a "commercial item," as that term is defined in 48 +C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer software" +and "commercial computer software documentation," as such terms are used +in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and +48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government +End Users acquire Covered Code with only those rights set forth herein. +You agree to pass this notice to our licensees. + +8.9 Marketing Activities. + +Licensee hereby grants Original Contributor a non-exclusive, +non-transferable, limited license to use the Licensee's company name and +logo ("Licensee Marks") in any presentations, press releases, or +marketing materials solely for the purpose of identifying Licensee as a +member of the Helix Community. Licensee shall provide samples of +Licensee Marks to Original Contributor upon request by Original +Contributor. Original Contributor acknowledges that the Licensee Marks +are the trademarks of Licensee. Original Contributor shall not use the +Licensee Marks in a way that may imply that Original Contributor is an +agency or branch of Licensee. Original Contributor understands and +agrees that the use of any Licensee Marks in connection with this +Agreement shall not create any right, title or interest, in, or to the +Licensee Marks or any Licensee trademarks and that all such use and +goodwill associated with any such trademarks will inure to the benefit +of Licensee. Further the Original Contributor will stop usage of the +Licensee Marks upon Licensee's request. + +8.10 Press Announcements. + +You may make press announcements or other public statements regarding +this License without the prior written consent of the Original +Contributor, if Your statement is limited to announcing the licensing of +the Covered Code or the availability of Your Product and its +compatibility with the Covered Code. All other public announcements +regarding this license require the prior written consent of the Original +Contributor. Consent requests are welcome at press@helixcommunity.org. + +8.11 International Use. + +a) Export/Import laws. Covered Code is subject to U.S. export control +laws and may be subject to export or import regulations in other +countries. Each party agrees to comply strictly with all such laws and +regulations and acknowledges their responsibility to obtain such +licenses to export, re-export, or import as may be required. You agree +to pass these obligations to Your licensees. + +b) Intellectual Property Protection. Due to limited intellectual +property protection and enforcement in certain countries, You agree not +to redistribute the Original Code, Upgraded Code, TCK and Specifications +to any country on the list of restricted countries on the Community Web +Server. + +8.12 Language. + +This License is in the English language only, which language shall be +controlling in all respects, and all versions of this License in any +other language shall be for accommodation only and shall not be binding +on the parties to this License. All communications and notices made or +given pursuant to this License, and all documentation and support to be +provided, unless otherwise noted, shall be in the English language. + +PLEASE READ THE TERMS OF THIS LICENSE CAREFULLY. BY CLICKING ON THE +"ACCEPT" BUTTON BELOW YOU ARE ACCEPTING AND AGREEING TO THE TERMS AND +CONDITIONS OF THIS LICENSE WITH REALNETWORKS, INC. IF YOU ARE AGREEING +TO THIS LICENSE ON BEHALF OF A COMPANY, YOU REPRESENT THAT YOU ARE +AUTHORIZED TO BIND THE COMPANY TO SUCH A LICENSE. WHETHER YOU ARE ACTING +ON YOUR OWN BEHALF, OR REPRESENTING A COMPANY, YOU MUST BE OF MAJORITY +AGE AND BE OTHERWISE COMPETENT TO ENTER INTO CONTRACTS. IF YOU DO NOT +MEET THIS CRITERIA OR YOU DO NOT AGREE TO ANY OF THE TERMS AND +CONDITIONS OF THIS LICENSE, CLICK ON THE REJECT BUTTON TO EXIT. + + + GLOSSARY + +1. *"Added Value"* means code which: + +(i) has a principal purpose which is substantially different from that +of the stand-alone Technology; + +(ii) represents a significant functional and value enhancement to the +Technology; + +(iii) operates in conjunction with the Technology; and + +(iv) is not marketed as a technology which replaces or substitutes for +the Technology + +2. "*Applicable Patent Rights*" mean: (a) in the case where Original +Contributor is the grantor of rights, claims of patents that (i) are now +or hereafter acquired, owned by or assigned to Original Contributor and +(ii) are necessarily infringed by using or making the Original Code or +Upgraded Code, including Modifications provided by Original Contributor, +alone and not in combination with other software or hardware; and (b) in +the case where Licensee is the grantor of rights, claims of patents that +(i) are now or hereafter acquired, owned by or assigned to Licensee and +(ii) are infringed (directly or indirectly) by using or making +Licensee's Modifications or Error Corrections, taken alone or in +combination with Covered Code. + +3. "*Application Programming Interfaces (APIs)"* means the interfaces, +associated header files, service provider interfaces, and protocols that +enable a device, application, Operating System, or other program to +obtain services from or make requests of (or provide services in +response to requests from) other programs, and to use, benefit from, or +rely on the resources, facilities, and capabilities of the relevant +programs using the APIs. APIs includes the technical documentation +describing the APIs, the Source Code constituting the API, and any +Header Files used with the APIs. + +4. "*Commercial Use*" means any use (internal or external), copying, +sublicensing or distribution (internal or external), directly or +indirectly of Covered Code by You other than Your Research Use of +Covered Code within Your business or organization or in conjunction with +other Licensees with equivalent Research Use rights. Commercial Use +includes any use of the Covered Code for direct or indirect commercial +or strategic gain, advantage or other business purpose. Any Commercial +Use requires execution of Attachment D by You and Original Contributor. + +5. "*Community Code*" means the Original Code, Upgraded Code, Error +Corrections, Shared Modifications, or any combination thereof. + +6. "*Community Webserver(s)"* means the webservers designated by +Original Contributor for access to the Original Code, Upgraded Code, TCK +and Specifications and for posting Error Corrections and Shared +Modifications. + +7. "*Compliant Covered Code*" means Covered Code that complies with the +requirements of the TCK. + +8. "*Contributor*" means each Licensee that creates or contributes to +the creation of any Error Correction or Shared Modification. + +9. "*Covered Code*" means the Original Code, Upgraded Code, +Modifications, or any combination thereof. + +10. "*Error Correction*" means any change made to Community Code which +conforms to the Specification and corrects the adverse effect of a +failure of Community Code to perform any function set forth in or +required by the Specifications. + +11. "*Executable*" means Covered Code that has been converted from +Source Code to the preferred form for execution by a computer or digital +processor (e.g. binary form). + +12. "*Extension(s)"* means any additional Interfaces developed by or for +You which: (i) are designed for use with the Technology; (ii) constitute +an API for a library of computing functions or services; and (iii) are +disclosed or otherwise made available to third party software developers +for the purpose of developing software which invokes such additional +Interfaces. The foregoing shall not apply to software developed by Your +subcontractors to be exclusively used by You. + +13. "*Header File(s)"* means that portion of the Source Code that +provides the names and types of member functions, data members, class +definitions, and interface definitions necessary to implement the APIs +for the Covered Code. Header Files include, files specifically +designated by Original Contributor as Header Files. Header Files do not +include the code necessary to implement the functionality underlying the +Interface. + +14. *"Helix DNA Server Technology"* means the program(s) that implement +the Helix Universal Server streaming engine for the Technology as +defined in the Specification. + +15. *"Helix DNA Client Technology"* means the Covered Code that +implements the RealOne Player engine as defined in the Specification. + +16. *"Helix DNA Producer Technology"* means the Covered Code that +implements the Helix Producer engine as defined in the Specification. + +17. *"Helix DNA Technology"* means the Helix DNA Server Technology, the +Helix DNA Client Technology, the Helix DNA Producer Technology and other +Helix technologies designated by Original Contributor. + +18. "*Intellectual Property Rights*" means worldwide statutory and +common law rights associated solely with (i) Applicable Patent Rights; +(ii) works of authorship including copyrights, copyright applications, +copyright registrations and "moral rights"; (iii) the protection of +trade and industrial secrets and confidential information; and (iv) +divisions, continuations, renewals, and re-issuances of the foregoing +now existing or acquired in the future. + +19. *"Interface*" means interfaces, functions, properties, class +definitions, APIs, Header Files, GUIDs, V-Tables, and/or protocols +allowing one piece of software, firmware or hardware to communicate or +interoperate with another piece of software, firmware or hardware. + +20. "*Internal Deployment Use*" means use of Compliant Covered Code +(excluding Research Use) within Your business or organization only by +Your employees and/or agents on behalf of Your business or organization, +but not to provide services, including content distribution, to third +parties, subject to execution of Attachment D by You and Original +Contributor, if required. + +21. "*Licensee*" means any party that has entered into and has in effect +a version of this License with Original Contributor. + +22. "*MIME type*" means a description of what type of media or other +content is in a file, including by way of example but not limited to +'audio/x-pn-realaudio-plugin.' + +23. "*Modification(s)"* means (i) any addition to, deletion from and/or +change to the substance and/or structure of the Covered Code, including +Interfaces; (ii) the combination of any Covered Code and any previous +Modifications; (iii) any new file or other representation of computer +program statements that contains any portion of Covered Code; and/or +(iv) any new Source Code implementing any portion of the Specifications. + +24. "*MP3 Patents*" means any patents necessary to make, use or sell +technology implementing any portion of the specification developed by +the Moving Picture Experts Group known as MPEG-1 Audio Layer-3 or MP3, +including but not limited to all past and future versions, profiles, +extensions, parts and amendments relating to the MP3 specification. + +25. "*MPEG-4 Patents*" means any patents necessary to make, use or sell +technology implementing any portion of the specification developed by +the Moving Pictures Experts Group known as MPEG-4, including but not +limited to all past and future versions, profiles, extensions, parts and +amendments relating to the MPEG-4 specification. + +26. "*Original Code*" means the initial Source Code for the Technology +as described on the Community Web Server. + +27. "*Original Contributor*" means RealNetworks, Inc., its affiliates +and its successors and assigns. + +28. "*Original Contributor MIME Type*" means the MIME registry, browser +preferences, or local file/protocol associations invoking any Helix DNA +Client-based application, including the RealOne Player, for playback of +RealAudio, RealVideo, other RealMedia MIME types or datatypes (e.g., +.ram, .rnx, .rpm, .ra, .rm, .rp, .rt, .rf, .prx, .mpe, .rmp, .rmj, .rav, +.rjs, .rmx, .rjt, .rms), and any other Original Contributor-specific or +proprietary MIME types that Original Contributor may introduce in the +future. + +29. "*Personal Use*" means use of Covered Code by an individual solely +for his or her personal, private and non-commercial purposes. An +individual's use of Covered Code in his or her capacity as an officer, +employee, member, independent contractor or agent of a corporation, +business or organization (commercial or non-commercial) does not qualify +as Personal Use. + +30. "*RealMedia File Format*" means the file format designed and +developed by RealNetworks for storing multimedia data and used to store +RealAudio and RealVideo encoded streams. Valid RealMedia File Format +extensions include: .rm, .rmj, .rmc, .rmvb, .rms. + +31. "*RCSL Webpage*" means the RealNetworks Community Source License +webpage located at https://www.helixcommunity.org/content/rcsl or such +other URL that Original Contributor may designate from time to time. + +32. "*Reformatted Specifications*" means any revision to the +Specifications which translates or reformats the Specifications (as for +example in connection with Your documentation) but which does not alter, +subset or superset * *the functional or operational aspects of the +Specifications. + +33. "*Research Use*" means use and distribution of Covered Code only for +Your Personal Use, research or development use and expressly excludes +Internal Deployment Use and Commercial Use. Research Use also includes +use of Covered Code to teach individuals how to use Covered Code. + +34. "*Shared Modifications*" means Modifications that You distribute or +use for a Commercial Use, in addition to any Modifications provided by +You, at Your option, pursuant to Section 2.2, or received by You from a +Contributor pursuant to Section 2.3. + +35. "*Source Code*" means the preferred form of the Covered Code for +making modifications to it, including all modules it contains, plus any +associated interface definition files, scripts used to control +compilation and installation of an Executable, or source code +differential comparisons against either the Original Code or another +well known, available Covered Code of the Contributor's choice. The +Source Code can be in a compressed or archival form, provided the +appropriate decompression or de-archiving software is widely available +for no charge. + +36. "*Specifications*" means the specifications for the Technology and +other documentation, as designated on the Community Web Server, as may +be revised by Original Contributor from time to time. + +37. "*Trademarks*" means Original Contributor's trademarks and logos, +including, but not limited to, RealNetworks, RealAudio, RealVideo, +RealOne, RealSystem, SureStream, Helix, Helix DNA and other trademarks +whether now used or adopted in the future. + +38. "*Technology*" means the technology described in Attachment B, and +Upgrades. + +39. "*Technology Compatibility Kit"* or *"TCK*" means the test programs, +procedures, acceptance criteria and/or other requirements, designated by +Original Contributor for use in verifying compliance of Covered Code +with the Specifications, in conjunction with the Original Code and +Upgraded Code. Original Contributor may, in its sole discretion and from +time to time, revise a TCK to correct errors and/or omissions and in +connection with Upgrades. + +40. "*Upgrade(s)"* means new versions of Technology designated +exclusively by Original Contributor as an "Upgrade" and released by +Original Contributor from time to time under the terms of the License. + +41. "*Upgraded Code*" means the Source Code and/or Executables for +Upgrades, possibly including Modifications made by Contributors. + +42. *"User's Guide"* means the users guide for the TCK which Original +Contributor makes available to You to provide direction in how to run +the TCK and properly interpret the results, as may be revised by +Original Contributor from time to time. + +43. "*You(r)*" means an individual, or a legal entity acting by and +through an individual or individuals, exercising rights either under +this License or under a future version of this License issued pursuant +to Section 4.1. For legal entities, "You(r)" includes any entity that by +majority voting interest controls, is controlled by, or is under common +control with You. + +44. "*Your Products*" means any (i) hardware products You distribute +integrating the Covered Code; (ii) any software products You distribute +with the Covered Code that utilize the APIs of the Covered Code; or +(iii) any services You provide using the Covered Code. + + + ATTACHMENT A + +REQUIRED NOTICES + + + ATTACHMENT A-1 + +REQUIRED IN ALL CASES + +Notice to be included in header file of all Error Corrections and Shared +Modifications: + +Portions Copyright 1994-2003 © RealNetworks, Inc. All rights reserved. + +The contents of this file, and the files included with this file, are +subject to the current version of RealNetworks Community Source License +Version 1.1 (the "License"). You may not use this file except in +compliance with the License executed by both You and RealNetworks. You +may obtain a copy of the License at * +https://www.helixcommunity.org/content/rcsl.* You may also obtain a copy +of the License by contacting RealNetworks directly. Please see the +License for the rights, obligations and limitations governing use of the +contents of the file. + +This file is part of the Helix DNA technology. RealNetworks, Inc., is +the developer of the Original code and owns the copyrights in the +portions it created. + +This file, and the files included with this file, are distributed on an +'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, +AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT +LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + +Contributor(s): + +_______________________________________________ + +Technology Compatibility Kit Test Suite(s) Location: + +________________________________ + + + ATTACHMENT A-2 + +SAMPLE LICENSEE CERTIFICATION + +"By clicking the `Agree' button below, You certify that You are a +Licensee in good standing under the RealNetworks Community Source +License, ("License") and that Your access, use and distribution of code +and information You may obtain at this site is subject to the License. +If You are not a Licensee under the RealNetworks Community Source +License You agree not to download, copy or use the Helix DNA technology. + + + ATTACHMENT A-3 + +REQUIRED STUDENT NOTIFICATION + +"This software and related documentation has been obtained by Your +educational institution subject to the RealNetworks Community Source +License. You have been provided access to the software and related +documentation for use only in connection with your course work and +research activities as a matriculated student of Your educational +institution. Any other use is expressly prohibited. + +THIS SOFTWARE AND RELATED DOCUMENTATION CONTAINS PROPRIETARY MATERIAL OF +REALNETWORKS, INC, WHICH ARE PROTECTED BY VARIOUS INTELLECTUAL PROPERTY +RIGHTS. + +You may not use this file except in compliance with the License. You may +obtain a copy of the License on the web at +https://www.helixcommunity.org/content/rcsl. + +* +* + + + ATTACHMENT B + +Description of Technology + +Helix DNA, which consists of Helix DNA Client, Helix DNA Server and +Helix DNA Producer. + +Description of "Technology" + +Helix DNA Technology v1.0 as described on the Community Web Server. + + + ATTACHMENT C + +TECHNOLOGY COMPATIBILITY KIT LICENSE + +The following license is effective for the *Helix DNA* Technology +Compatibility Kit - as described on the Community Web Server. The +Technology Compatibility Kit(s) for the Technology specified in +Attachment B may be accessed at the Community Web Server. + +1. TCK License. + +1.1 Grants to use TCK + +Subject to the terms and restrictions set forth below and the +RealNetworks Community Source License, and the Research Use license, +Original Contributor grants to You a worldwide, non-exclusive, +non-transferable license, to the extent of Original Contributor's +Intellectual Property Rights in the TCK (without the right to +sublicense), to use the TCK to develop and test Covered Code. + +1.2 TCK Use Restrictions. + +You are not authorized to create derivative works of the TCK or use the +TCK to test any implementation of the Specification that is not Covered +Code. You may not publish Your test results or make claims of +comparative compatibility with respect to other implementations of the +Specification. In consideration for the license grant in Section 1.1 +above You agree not to develop Your own tests that are intended to +validate conformation with the Specification. + +2. Test Results. + +You agree to provide to Original Contributor or the third party test +facility if applicable, Your test results that demonstrate that Covered +Code is Compliant Covered Code and that Original Contributor may publish +or otherwise distribute such test results. + +PLEASE READ THE TERMS OF THIS LICENSE CAREFULLY. BY CLICKING ON THE +"ACCEPT" BUTTON BELOW YOU ARE ACCEPTING AND AGREEING TO THE TERMS AND +CONDITIONS OF THIS LICENSE WITH THE ORIGINAL CONTRIBUTOR, REALNETWORKS, +INC. IF YOU ARE AGREEING TO THIS LICENSE ON BEHALF OF A COMPANY, YOU +REPRESENT THAT YOU ARE AUTHORIZED TO BIND THE COMPANY TO SUCH A LICENSE. +WHETHER YOU ARE ACTING ON YOUR OWN BEHALF, OR REPRESENTING A COMPANY, +YOU MUST BE OF MAJORITY AGE AND BE OTHERWISE COMPETENT TO ENTER INTO +CONTRACTS. IF YOU DO NOT MEET THIS CRITERIA OR YOU DO NOT AGREE TO ANY +OF THE TERMS AND CONDITIONS OF THIS LICENSE, CLICK ON THE REJECT BUTTON +TO EXIT. + +*ACCEPT / REJECT +* + +* +* + +*To agree to the R&D/academic terms of this license, please register + on the site -- +you will then be given a chance to agree to the clickwrap RCSL + +R&D License + +and gain access to the RCSL-licensed source code. To build or deploy +commercial applications based on the RCSL, you will need to agree to the +Commercial Use license attachments +* + + + Index: helix-libs/clientapps/clutter/RPSL.txt =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/RPSL.txt 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,518 @@ +RealNetworks Public Source License Version 1.0 +(Rev. Date October 28, 2002) + +1. General Definitions. This License applies to any program or other work which +RealNetworks, Inc., or any other entity that elects to use this license, +("Licensor") makes publicly available and which contains a notice placed by +Licensor identifying such program or work as "Original Code" and stating that it +is subject to the terms of this RealNetworks Public Source License version 1.0 +(or subsequent version thereof) ("License"). You are not required to accept this +License. However, nothing else grants You permission to use, copy, modify or +distribute the software or its derivative works. These actions are prohibited by +law if You do not accept this License. Therefore, by modifying, copying or +distributing the software (or any work based on the software), You indicate your +acceptance of this License to do so, and all its terms and conditions. In +addition, you agree to the terms of this License by clicking the Accept button +or downloading the software. As used in this License: + +1.1 "Applicable Patent Rights" mean: (a) in the case where Licensor is the +grantor of rights, claims of patents that (i) are now or hereafter acquired, +owned by or assigned to Licensor and (ii) are necessarily infringed by using or +making the Original Code alone and not in combination with other software or +hardware; and (b) in the case where You are the grantor of rights, claims of +patents that (i) are now or hereafter acquired, owned by or assigned to You and +(ii) are infringed (directly or indirectly) by using or making Your +Modifications, taken alone or in combination with Original Code. + +1.2 "Compatible Source License" means any one of the licenses listed on Exhibit +B or at https://www.helixcommunity.org/content/complicense or other licenses +specifically identified by Licensor in writing. Notwithstanding any term to the +contrary in any Compatible Source License, any code covered by any Compatible +Source License that is used with Covered Code must be made readily available in +Source Code format for royalty-free use under the terms of the Compatible Source +License or this License. + +1.3 "Contributor" means any person or entity that creates or contributes to the +creation of Modifications. + +1.4 "Covered Code" means the Original Code, Modifications, the combination of +Original Code and any Modifications, and/or any respective portions thereof. + +1.5 "Deploy" means to use, sublicense or distribute Covered Code other than for +Your internal research and development (R&D) and/or Personal Use, and includes +without limitation, any and all internal use or distribution of Covered Code +within Your business or organization except for R&D use and/or Personal Use, as +well as direct or indirect sublicensing or distribution of Covered Code by You +to any third party in any form or manner. + +1.6 "Derivative Work" means either the Covered Code or any derivative work under +United States copyright law, and including any work containing or including any +portion of the Covered Code or Modifications, either verbatim or with +modifications and/or translated into another language. Derivative Work also +includes any work which combines any portion of Covered Code or Modifications +with code not otherwise governed by the terms of this License. + +1.7 "Externally Deploy" means to Deploy the Covered Code in any way that may be +accessed or used by anyone other than You, used to provide any services to +anyone other than You, or used in any way to deliver any content to anyone other +than You, whether the Covered Code is distributed to those parties, made +available as an application intended for use over a computer network, or used to +provide services or otherwise deliver content to anyone other than You. + +1.8. "Interface" means interfaces, functions, properties, class definitions, +APIs, header files, GUIDs, V-Tables, and/or protocols allowing one piece of +software, firmware or hardware to communicate or interoperate with another piece +of software, firmware or hardware. + +1.9 "Modifications" mean any addition to, deletion from, and/or change to, the +substance and/or structure of the Original Code, any previous Modifications, the +combination of Original Code and any previous Modifications, and/or any +respective portions thereof. When code is released as a series of files, a +Modification is: (a) any addition to or deletion from the contents of a file +containing Covered Code; and/or (b) any new file or other representation of +computer program statements that contains any part of Covered Code. + +1.10 "Original Code" means (a) the Source Code of a program or other work as +originally made available by Licensor under this License, including the Source +Code of any updates or upgrades to such programs or works made available by +Licensor under this License, and that has been expressly identified by Licensor +as such in the header file(s) of such work; and (b) the object code compiled +from such Source Code and originally made available by Licensor under this +License. + +1.11 "Personal Use" means use of Covered Code by an individual solely for his or +her personal, private and non-commercial purposes. An individual's use of +Covered Code in his or her capacity as an officer, employee, member, independent +contractor or agent of a corporation, business or organization (commercial or +non-commercial) does not qualify as Personal Use. + +1.12 "Source Code" means the human readable form of a program or other work that +is suitable for making modifications to it, including all modules it contains, +plus any associated interface definition files, scripts used to control +compilation and installation of an executable (object code). + +1.13 "You" or "Your" means an individual or a legal entity exercising rights +under this License. For legal entities, "You" or "Your" includes any entity +which controls, is controlled by, or is under common control with, You, where +"control" means (a) the power, direct or indirect, to cause the direction or +management of such entity, whether by contract or otherwise, or (b) ownership of +fifty percent (50%) or more of the outstanding shares or beneficial ownership of +such entity. + +2. Permitted Uses; Conditions & Restrictions. Subject to the terms and +conditions of this License, Licensor hereby grants You, effective on the date +You accept this License (via downloading or using Covered Code or otherwise +indicating your acceptance of this License), a worldwide, royalty-free, +non-exclusive copyright license, to the extent of Licensor's copyrights cover +the Original Code, to do the following: + +2.1 You may reproduce, display, perform, modify and Deploy Covered Code, +provided that in each instance: + +(a) You must retain and reproduce in all copies of Original Code the copyright +and other proprietary notices and disclaimers of Licensor as they appear in the +Original Code, and keep intact all notices in the Original Code that refer to +this License; + +(b) You must include a copy of this License with every copy of Source Code of +Covered Code and documentation You distribute, and You may not offer or impose +any terms on such Source Code that alter or restrict this License or the +recipients' rights hereunder, except as permitted under Section 6; + +(c) You must duplicate, to the extent it does not already exist, the notice in +Exhibit A in each file of the Source Code of all Your Modifications, and cause +the modified files to carry prominent notices stating that You changed the files +and the date of any change; + +(d) You must make Source Code of all Your Externally Deployed Modifications +publicly available under the terms of this License, including the license grants +set forth in Section 3 below, for as long as you Deploy the Covered Code or +twelve (12) months from the date of initial Deployment, whichever is longer. You +should preferably distribute the Source Code of Your Deployed Modifications +electronically (e.g. download from a web site); and + +(e) if You Deploy Covered Code in object code, executable form only, You must +include a prominent notice, in the code itself as well as in related +documentation, stating that Source Code of the Covered Code is available under +the terms of this License with information on how and where to obtain such +Source Code. You must also include the Object Code Notice set forth in Exhibit A +in the "about" box or other appropriate place where other copyright notices are +placed, including any packaging materials. + +2.2 You expressly acknowledge and agree that although Licensor and each +Contributor grants the licenses to their respective portions of the Covered Code +set forth herein, no assurances are provided by Licensor or any Contributor that +the Covered Code does not infringe the patent or other intellectual property +rights of any other entity. Licensor and each Contributor disclaim any liability +to You for claims brought by any other entity based on infringement of +intellectual property rights or otherwise. As a condition to exercising the +rights and licenses granted hereunder, You hereby assume sole responsibility to +secure any other intellectual property rights needed, if any. For example, if a +third party patent license is required to allow You to make, use, sell, import +or offer for sale the Covered Code, it is Your responsibility to acquire such +license(s). + +2.3 Subject to the terms and conditions of this License, Licensor hereby grants +You, effective on the date You accept this License (via downloading or using +Covered Code or otherwise indicating your acceptance of this License), a +worldwide, royalty-free, perpetual, non-exclusive patent license under +Licensor's Applicable Patent Rights to make, use, sell, offer for sale and +import the Covered Code, provided that in each instance you comply with the +terms of this License. + +3. Your Grants. In consideration of, and as a condition to, the licenses granted +to You under this License: + +(a) You grant to Licensor and all third parties a non-exclusive, perpetual, +irrevocable, royalty free license under Your Applicable Patent Rights and other +intellectual property rights owned or controlled by You, to make, sell, offer +for sale, use, import, reproduce, display, perform, modify, distribute and +Deploy Your Modifications of the same scope and extent as Licensor's licenses +under Sections 2.1 and 2.2; and + +(b) You grant to Licensor and its subsidiaries a non-exclusive, worldwide, +royalty-free, perpetual and irrevocable license, under Your Applicable Patent +Rights and other intellectual property rights owned or controlled by You, to +make, use, sell, offer for sale, import, reproduce, display, perform, +distribute, modify or have modified (for Licensor and/or its subsidiaries), +sublicense and distribute Your Modifications, in any form and for any purpose, +through multiple tiers of distribution. + +(c) You agree not use any information derived from Your use and review of the +Covered Code, including but not limited to any algorithms or inventions that may +be contained in the Covered Code, for the purpose of asserting any of Your +patent rights, or assisting a third party to assert any of its patent rights, +against Licensor or any Contributor. + +4. Derivative Works. You may create a Derivative Work by combining Covered Code +with other code not otherwise governed by the terms of this License and +distribute the Derivative Work as an integrated product. In each such instance, +You must make sure the requirements of this License are fulfilled for the +Covered Code or any portion thereof, including all Modifications. + +4.1 You must cause any Derivative Work that you distribute, publish or +Externally Deploy, that in whole or in part contains or is derived from the +Covered Code or any part thereof, to be licensed as a whole at no charge to all +third parties under the terms of this License and no other license except as +provided in Section 4.2. You also must make Source Code available for the +Derivative Work under the same terms as Modifications, described in Sections 2 +and 3, above. + +4.2 Compatible Source Licenses. Software modules that have been independently +developed without any use of Covered Code and which contain no portion of the +Covered Code, Modifications or other Derivative Works, but are used or combined +in any way wtih the Covered Code or any Derivative Work to form a larger +Derivative Work, are exempt from the conditions described in Section 4.1 but +only to the extent that: the software module, including any software that is +linked to, integrated with, or part of the same applications as, the software +module by any method must be wholly subject to one of the Compatible Source +Licenses. Notwithstanding the foregoing, all Covered Code must be subject to the +terms of this License. Thus, the entire Derivative Work must be licensed under a +combination of the RPSL (for Covered Code) and a Compatible Source License for +any independently developed software modules within the Derivative Work. The +foregoing requirement applies even if the Compatible Source License would +ordinarily allow the software module to link with, or form larger works with, +other software that is not subject to the Compatible Source License. For +example, although the Mozilla Public License v1.1 allows Mozilla code to be +combined with proprietary software that is not subject to the MPL, if +MPL-licensed code is used with Covered Code the MPL-licensed code could not be +combined or linked with any code not governed by the MPL. The general intent of +this section 4.2 is to enable use of Covered Code with applications that are +wholly subject to an acceptable open source license. You are responsible for +determining whether your use of software with Covered Code is allowed under Your +license to such software. + +4.3 Mere aggregation of another work not based on the Covered Code with the +Covered Code (or with a work based on the Covered Code) on a volume of a storage +or distribution medium does not bring the other work under the scope of this +License. If You deliver the Covered Code for combination and/or integration with +an application previously provided by You (for example, via automatic updating +technology), such combination and/or integration constitutes a Derivative Work +subject to the terms of this License. + +5. Exclusions From License Grant. Nothing in this License shall be deemed to +grant any rights to trademarks, copyrights, patents, trade secrets or any other +intellectual property of Licensor or any Contributor except as expressly stated +herein. No right is granted to the trademarks of Licensor or any Contributor +even if such marks are included in the Covered Code. Nothing in this License +shall be interpreted to prohibit Licensor from licensing under different terms +from this License any code that Licensor otherwise would have a right to +license. Modifications, Derivative Works and/or any use or combination of +Covered Code with other technology provided by Licensor or third parties may +require additional patent licenses from Licensor which Licensor may grant in its +sole discretion. No patent license is granted separate from the Original Code or +combinations of the Original Code with other software or hardware. + +5.1. Trademarks. This License does not grant any rights to use the trademarks or +trade names owned by Licensor ("Licensor Marks" defined in Exhibit C) or to any +trademark or trade name belonging to any Contributor. No Licensor Marks may be +used to endorse or promote products derived from the Original Code other than as +permitted by the Licensor Trademark Policy defined in Exhibit C. + +6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, +support, indemnity or liability obligations and/or other rights consistent with +the scope of the license granted herein ("Additional Terms") to one or more +recipients of Covered Code. However, You may do so only on Your own behalf and +as Your sole responsibility, and not on behalf of Licensor or any Contributor. +You must obtain the recipient's agreement that any such Additional Terms are +offered by You alone, and You hereby agree to indemnify, defend and hold +Licensor and every Contributor harmless for any liability incurred by or claims +asserted against Licensor or such Contributor by reason of any such Additional +Terms. + +7. Versions of the License. Licensor may publish revised and/or new versions of +this License from time to time. Each version will be given a distinguishing +version number. Once Original Code has been published under a particular version +of this License, You may continue to use it under the terms of that version. You +may also choose to use such Original Code under the terms of any subsequent +version of this License published by Licensor. No one other than Licensor has +the right to modify the terms applicable to Covered Code created under this +License. + +8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part +pre-release, untested, or not fully tested works. The Covered Code may contain +errors that could cause failures or loss of data, and may be incomplete or +contain inaccuracies. You expressly acknowledge and agree that use of the +Covered Code, or any portion thereof, is at Your sole and entire risk. THE +COVERED CODE IS PROVIDED "AS IS" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF +ANY KIND AND LICENSOR AND LICENSOR'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS +"LICENSOR" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY +DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT +NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF +SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET +ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. LICENSOR AND EACH +CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE +COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR +REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR +ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR +WRITTEN DOCUMENTATION, INFORMATION OR ADVICE GIVEN BY LICENSOR, A LICENSOR +AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You +acknowledge that the Covered Code is not intended for use in high risk +activities, including, but not limited to, the design, construction, operation +or maintenance of nuclear facilities, aircraft navigation, aircraft +communication systems, or air traffic control machines in which case the failure +of the Covered Code could lead to death, personal injury, or severe physical or +environmental damage. Licensor disclaims any express or implied warranty of +fitness for such uses. + +9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT +SHALL LICENSOR OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, +INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR +YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER +UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE OR STRICT +LIABILITY), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF LICENSOR OR SUCH +CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND +NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME +JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR +CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event +shall Licensor's total liability to You for all damages (other than as may be +required by applicable law) under this License exceed the amount of ten dollars +($10.00). + +10. Ownership. Subject to the licenses granted under this License, each +Contributor retains all rights, title and interest in and to any Modifications +made by such Contributor. Licensor retains all rights, title and interest in and +to the Original Code and any Modifications made by or on behalf of Licensor +("Licensor Modifications"), and such Licensor Modifications will not be +automatically subject to this License. Licensor may, at its sole discretion, +choose to license such Licensor Modifications under this License, or on +different terms from those contained in this License or may choose not to +license them at all. + +11. Termination. + +11.1 Term and Termination. The term of this License is perpetual unless +terminated as provided below. This License and the rights granted hereunder will +terminate: + +(a) automatically without notice from Licensor if You fail to comply with any +term(s) of this License and fail to cure such breach within 30 days of becoming +aware of such breach; + +(b) immediately in the event of the circumstances described in Section 12.5(b); +or + +(c) automatically without notice from Licensor if You, at any time during the +term of this License, commence an action for patent infringement against +Licensor (including by cross-claim or counter claim in a lawsuit); + +(d) upon written notice from Licensor if You, at any time during the term of +this License, commence an action for patent infringement against any third party +alleging that the Covered Code itself (excluding combinations with other +software or hardware) infringes any patent (including by cross-claim or counter +claim in a lawsuit). + +11.2 Effect of Termination. Upon termination, You agree to immediately stop any +further use, reproduction, modification, sublicensing and distribution of the +Covered Code and to destroy all copies of the Covered Code that are in your +possession or control. All sublicenses to the Covered Code which have been +properly granted prior to termination shall survive any termination of this +License. Provisions which, by their nature, should remain in effect beyond the +termination of this License shall survive, including but not limited to Sections +3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for +compensation, indemnity or damages of any sort solely as a result of terminating +this License in accordance with its terms, and termination of this License will +be without prejudice to any other right or remedy of any party. + +12. Miscellaneous. + +12.1 Government End Users. The Covered Code is a "commercial item" as defined in +FAR 2.101. Government software and technical data rights in the Covered Code +include only those rights customarily provided to the public as defined in this +License. This customary commercial license in technical data and software is +provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer +Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical +Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software +or Computer Software Documentation). Accordingly, all U.S. Government End Users +acquire Covered Code with only those rights set forth herein. + +12.2 Relationship of Parties. This License will not be construed as creating an +agency, partnership, joint venture or any other form of legal association +between or among You, Licensor or any Contributor, and You will not represent to +the contrary, whether expressly, by implication, appearance or otherwise. + +12.3 Independent Development. Nothing in this License will impair Licensor's +right to acquire, license, develop, have others develop for it, market and/or +distribute technology or products that perform the same or similar functions as, +or otherwise compete with, Modifications, Derivative Works, technology or +products that You may develop, produce, market or distribute. + +12.4 Waiver; Construction. Failure by Licensor or any Contributor to enforce any +provision of this License will not be deemed a waiver of future enforcement of +that or any other provision. Any law or regulation which provides that the +language of a contract shall be construed against the drafter will not apply to +this License. + +12.5 Severability. (a) If for any reason a court of competent jurisdiction finds +any provision of this License, or portion thereof, to be unenforceable, that +provision of the License will be enforced to the maximum extent permissible so +as to effect the economic benefits and intent of the parties, and the remainder +of this License will continue in full force and effect. (b) Notwithstanding the +foregoing, if applicable law prohibits or restricts You from fully and/or +specifically complying with Sections 2 and/or 3 or prevents the enforceability +of either of those Sections, this License will immediately terminate and You +must immediately discontinue any use of the Covered Code and destroy all copies +of it that are in your possession or control. + +12.6 Dispute Resolution. Any litigation or other dispute resolution between You +and Licensor relating to this License shall take place in the Seattle, +Washington, and You and Licensor hereby consent to the personal jurisdiction of, +and venue in, the state and federal courts within that District with respect to +this License. The application of the United Nations Convention on Contracts for +the International Sale of Goods is expressly excluded. + +12.7 Export/Import Laws. This software is subject to all export and import laws +and restrictions and regulations of the country in which you receive the Covered +Code and You are solely responsible for ensuring that You do not export, +re-export or import the Covered Code or any direct product thereof in violation +of any such restrictions, laws or regulations, or without all necessary +authorizations. + +12.8 Entire Agreement; Governing Law. This License constitutes the entire +agreement between the parties with respect to the subject matter hereof. This +License shall be governed by the laws of the United States and the State of +Washington. + +Where You are located in the province of Quebec, Canada, the following clause +applies: The parties hereby confirm that they have requested that this License +and all related documents be drafted in English. Les parties ont exigé +que le présent contrat et tous les documents connexes soient +rédigés en anglais. + + EXHIBIT A. + +"Copyright © 1995-2002 +RealNetworks, Inc. and/or its licensors. All Rights Reserved. + +The contents of this file, and the files included with this file, are subject to +the current version of the RealNetworks Public Source License Version 1.0 (the +"RPSL") available at https://www.helixcommunity.org/content/rpsl unless you have +licensed the file under the RealNetworks Community Source License Version 1.0 +(the "RCSL") available at https://www.helixcommunity.org/content/rcsl, in which +case the RCSL will apply. You may also obtain the license terms directly from +RealNetworks. You may not use this file except in compliance with the RPSL or, +if you have a valid RCSL with RealNetworks applicable to this file, the RCSL. +Please see the applicable RPSL or RCSL for the rights, obligations and +limitations governing use of the contents of the file. + +This file is part of the Helix DNA Technology. RealNetworks is the developer of +the Original code and owns the copyrights in the portions it created. + +This file, and the files included with this file, is distributed and made +available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR +IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING +WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + +Contributor(s): ____________________________________ + +Technology Compatibility Kit Test +Suite(s) Location (if licensed under the RCSL): ______________________________ + +Object Code Notice: Helix DNA Client technology included. Copyright (c) +RealNetworks, Inc., 1995-2002. All rights reserved. + + + EXHIBIT B + +Compatible Source Licenses for the RealNetworks Public Source License. The +following list applies to the most recent version of the license as of October +25, 2002, unless otherwise indicated. + +* Academic Free License +* Apache Software License +* Apple Public Source License +* Artistic license +* Attribution Assurance Licenses +* BSD license +* Common Public License (1) +* Eiffel Forum License +* GNU General Public License (GPL) (1) +* GNU Library or "Lesser" General Public License (LGPL) (1) +* IBM Public License +* Intel Open Source License +* Jabber Open Source License +* MIT license +* MITRE Collaborative Virtual Workspace License (CVW License) +* Motosoto License +* Mozilla Public License 1.0 (MPL) +* Mozilla Public License 1.1 (MPL) +* Nokia Open Source License +* Open Group Test Suite License +* Python Software Foundation License +* Ricoh Source Code Public License +* Sun Industry Standards Source License (SISSL) +* Sun Public License +* University of Illinois/NCSA Open Source License +* Vovida Software License v. 1.0 +* W3C License +* X.Net License +* Zope Public License +* zlib/libpng license + +(1) Note: because this license contains certain reciprocal licensing terms that +purport to extend to independently developed code, You may be prohibited under +the terms of this otherwise compatible license from using code licensed under +its terms with Covered Code because Covered Code may only be licensed under the +RealNetworks Public Source License. Any attempt to apply non RPSL license terms, +including without limitation the GPL, to Covered Code is expressly forbidden. +You are responsible for ensuring that Your use of Compatible Source Licensed +code does not violate either the RPSL or the Compatible Source License. + +The latest version of this list can be found at: +https://www.helixcommunity.org/content/complicense + + EXHIBIT C + +RealNetworks' Trademark policy. + +RealNetworks defines the following trademarks collectively as "Licensor +Trademarks": "RealNetworks", "RealPlayer", "RealJukebox", "RealSystem", +"RealAudio", "RealVideo", "RealOne Player", "RealMedia", "Helix" or any other +trademarks or trade names belonging to RealNetworks. + +RealNetworks "Licensor Trademark Policy" forbids any use of Licensor Trademarks +except as permitted by and in strict compliance at all times with RealNetworks' +third party trademark usage guidelines which are posted at +http://www.realnetworks.com/info/helixlogo.html. + Index: helix-libs/clientapps/clutter/Umakefil =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/Umakefil 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,325 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: RCSL 1.0/RPSL 1.0 +# +# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. +# +# The contents of this file, and the files included with this file, are +# subject to the current version of the RealNetworks Public Source License +# Version 1.0 (the "RPSL") available at +# http://www.helixcommunity.org/content/rpsl unless you have licensed +# the file under the RealNetworks Community Source License Version 1.0 +# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, +# in which case the RCSL will apply. You may also obtain the license terms +# directly from RealNetworks. You may not use this file except in +# compliance with the RPSL or, if you have a valid RCSL with RealNetworks +# applicable to this file, the RCSL. Please see the applicable RPSL or +# RCSL for the rights, obligations and limitations governing use of the +# contents of the file. +# +# This file is part of the Helix DNA Technology. RealNetworks is the +# developer of the Original Code and owns the copyrights in the portions +# it created. +# +# This file, and the files included with this file, is distributed and made +# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, +# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS +# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. +# +# Technology Compatibility Kit Test Suite(s) Location: +# http://www.helixcommunity.org/content/tck +# +# Contributor(s): +# +# ***** END LICENSE BLOCK ***** +# + +UmakefileVersion(2,2) + +project.AddModuleIncludes("common/include", + "common/runtime/pub", + "client/include", + "client/common/system/pub", + "client/common/container/pub", + "client/audiosvc/pub", + "common/container/pub", + "video/sitelib/pub", + "video/colconverter/pub", + "video/sitelib/pub/platform/unix", + "video/sitelib", + "datatype/rm/include", + "client/core") + +project.AddSources("player.cpp", + "excontxt.cpp", + "exsite.cpp", + "exroot.cpp", + "exadvsnk.cpp", + "exerror.cpp", + "iids.cpp", + "exstateadvsnk.cpp", + "excallback.cpp", + "print.cpp") + +project.AddModuleLibraries( + "common/runtime[runtlib]", + "common/system[syslib]", + "common/container[contlib]", + "common/runtime[runtlib]", + "client/common/system[sysclntlib]", + "common/dbgtool[debuglib]", + "common/util[utillib]", + "video/sitelib[sitelib]", + "video/sitelib[sitecreatelib]", + "common/log/logutil[logutillib]", + "video/vidutil[vidutillib]" + ) +project.AddSystemLibraries('Xv', 'Xext') + +if project.IsDefined("HELIX_FEATURE_PREFERENCES"): + project.AddSources("preflist.cpp") + +if project.IsDefined("HELIX_FEATURE_AUTHENTICATION"): + project.AddSources("exaumgr.cpp") + +if project.IsDefined("HELIX_FEATURE_VIDEO"): + project.AddSources("exsitsup.cpp", + "fivemmap.cpp") + project.AddModuleIncludes('video/include') + if project.IsDefined("HELIX_FEATURE_PNG"): + project.AddModuleIncludes('datatype/image/png/common/pub') + project.AddModuleLibraries("common/import/zlib[zlib]", + "datatype/image/png/import/libpng[libpng]", + "datatype/image/png/common[pngcomlib]") + +if project.IsDefined("HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS"): + project.AddSources("exprdnld.cpp") + +if project.BuildOption("nodll"): + ## Client core + static_plugin_list = ["clntcore"] + project.AddModuleLibraries("common/runtime[runtlib]", + "common/fileio[fileiolib]", + "client/common/system[sysclntlib]", + "client/common/container[contclntlib]", + "client/core[clntcorelib]") + if not project.IsDefined("HELIX_FEATURE_LOGLEVEL_NONE"): + project.AddModuleLibraries("common/log/logutil[logutillib]") + if not project.IsDefined("HELIX_CONFIG_MINIMIZE_SIZE"): + project.AddModuleLibraries("client/common/util[utlclntlib]") + ## Client core libraries + if project.IsDefined("HELIX_FEATURE_AUDIO"): + project.AddModuleLibraries("audio/device[auddevlib]", + "client/audiosvc[audsvclib]") + if ('HELIX_FEATURE_VOLUME' in project.defines): + project.AddModuleLibraries("audio/gaintool[audgainlib]" ) + if ('HELIX_FEATURE_VOLUME' in project.defines): + project.AddModuleLibraries("audio/crossfade[audxfadelib]") + if project.IsDefined("HELIX_FEATURE_MIXER"): + project.AddModuleLibraries("audio/mixer[audmixlib]") + if project.IsDefined("HELIX_FEATURE_RESAMPLER"): + project.AddModuleLibraries("audio/resampler[audresamplib]") + if project.IsDefined("HELIX_FEATURE_LIMITER"): + project.AddModuleLibraries("audio/limiter[audlimiter]") + + if project.IsDefined("HELIX_FEATURE_VIDEO"): + project.AddModuleLibraries("client/videosvc[vidsvclib]", + "protocol/sdp[sdplib]") + if project.IsDefined("HELIX_FEATURE_PLAYBACK_NET"): + project.AddModuleLibraries("client/netwksvc[netsvclib]", + "common/netio[netiolib]", + "client/common/netio[netioclntlib]", + "protocol/transport/common/system[systranlib]", + "protocol/transport/rtp[rtptranlib]", + "protocol/common/util[protutillib]", + "protocol/rtsp[rtsplib]") + if project.IsDefined("HELIX_FEATURE_RDT"): + project.AddLibraries(GetSDKPath("prtclrdt_lib")) + project.AddModuleLibraries("protocol/transport/rdt[rdttranlib]") + if project.IsDefined("HELIX_FEATURE_PNA"): + project.AddLibraries(GetSDKPath("prtclpna_lib")) + if project.IsDefined("HELIX_FEATURE_XMLPARSER"): + project.AddModuleLibraries("common/lang/xml[xmllib]") + ## Add RAM file format and renderer + if project.IsDefined("HELIX_FEATURE_META"): + static_plugin_list[-1:-1] = ["ramfformat", "ramrender"] + project.AddModuleLibraries("datatype/ram/renderer[ramrendrlib]") + ## Add local file system + if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL"): + static_plugin_list[-1:-1] = ["smplfsys"] + project.AddModuleLibraries("common/fileio[fileiolib]") + ## Add http file system + if project.IsDefined("HELIX_FEATURE_PLAYBACK_NET"): + static_plugin_list[-1:-1] = ["hxsdp", "httpfsys"] + project.AddModuleLibraries("protocol/http[httplib]", + "protocol/common/util[protutillib]", + "protocol/sdp[sdplib]", + "filesystem/data[datafsys]", + "common/fileio[fileiolib]", + "common/import/zlib[zlib]") + ## Add realmedia file format + if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL") and \ + (project.IsDefined("HELIX_FEATURE_AUDIO_REAL") or \ + project.IsDefined("HELIX_FEATURE_VIDEO_REAL")): + static_plugin_list[-1:-1] = ["rmfformat"] + project.AddModuleLibraries("datatype/common/util[dtutillib]", + "datatype/common/container[dtcomcontlib]") + project.AddLibraries(GetSDKPath("rmcom_lib"), + GetSDKPath("rmacom_lib"), + GetSDKPath("rmff_lib"), + GetSDKPath("rmvidpyld_lib")) + + ## Add realmedia renderer + if project.IsDefined("HELIX_FEATURE_AUDIO_REAL"): + static_plugin_list[-1:-1] = ["rarender"] + project.AddModuleLibraries("datatype/rm/audio/payload[rapayld]") + project.AddLibraries(GetSDKPath("rmarend_lib"), + GetSDKPath("rmacom_lib")) + ## Add mp3 file format and renderer + if project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER3") or \ + project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER2") or \ + project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER1"): + static_plugin_list[-1:-1] = ["mp3render"] + project.AddModuleLibraries("datatype/mp3/codec/fltpt[mp3codecfltpt]", + "datatype/mp3/common[mp3lib]", + "datatype/mp3/payload[mp3payld]", + "datatype/common/util[dtutillib]") + if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL"): + static_plugin_list[-1:-1] = ["mp3fformat"] + project.AddModuleLibraries("datatype/mp3/common[mp3lib]") + ## Add gecko realmedia codec + if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_GECKO"): + static_plugin_list[-1:-1] = ["cook"] + if not project.IsDefined("HELIX_CONFIG_FIXEDPOINT"): + project.AddLibraries(GetSDKPath("ra8lbrdec_flt_lib")) + else: + project.AddLibraries(GetSDKPath("ra8lbrdec_fix_lib")) + project.AddModuleLibraries("datatype/rm/audio/codec/common[racompat]") + ## Add RAAC codec + if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_RAAC"): + static_plugin_list[-1:-1] = ["raac"] + project.AddModuleLibraries("datatype/mp4/common[mp4comlib]", + "datatype/aac/codec/fixpt/decoder/hxwrap[aacdeclib]") + ## Add sipro realmedia codec + ## (Right now this only works for floating-point platforms) + if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_SIPRO"): + static_plugin_list[-1:-1] = ["sipr"] + project.AddLibraries(GetSDKPath("sipro_flt_backend_lib")) + ## Add tokyo realmedia codec + if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_TOKYO"): + static_plugin_list[-1:-1] = ["atrc"] + project.AddLibraries(GetSDKPath("ra8hbr_lib")) + ## + if project.IsDefined("HELIX_FEATURE_VIDEO"): + static_plugin_list[-1:-1] = ["vidsite"] + static_plugin_list[-1:-1] = ["hxltcolor"] + project.AddModuleLibraries("datatype/common/vidrend[vidrend]", + "video/sitelib[sitelib]", + "video/site[vidsite]", + "video/colconverter[hxltcolor]", + "datatype/rm/common[rmcomlib]", + "video/vidutil[vidutillib]") + + if (project.IsDefined('HELIX_FEATURE_ALTERNATE_SITE_CREATE_LIB')): + project.AddLibraries(GetSDKPath("sitecreate_lib")) + else: + project.AddModuleLibraries('video/sitelib[sitecreatelib]') + + ## Add realvideo renderer + if project.IsDefined("HELIX_FEATURE_VIDEO_REAL"): + project.AddModuleLibraries("datatype/rm/video/renderer[rvxrendlib]") + project.AddLibraries(GetSDKPath("rmvidcom_lib"), + GetSDKPath("rmvidpyld_lib"), + GetSDKPath("rvcodcom_lib")) + project.AddModuleLibraries("datatype/common/util[dtutillib]") + static_plugin_list[-1:-1] = ["rvrender"] + + ## Add mpeg4 file format + if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL")and \ + (project.IsDefined("HELIX_FEATURE_VIDEO_H263") or \ + project.IsDefined("HELIX_FEATURE_VIDEO_MPEG4") or \ + project.IsDefined("HELIX_FEATURE_AUDIO_MPEG4")): + static_plugin_list[-1:-1] = ["mp4fformat"] + project.AddModuleLibraries("datatype/common/util[dtutillib]", + "datatype/common/audrend", + "datatype/mp4/common[mp4comlib]", + "datatype/mp4/payload[mp4pyldlib]", + "datatype/mp4/fileformat[mp4fformatlib]") + if not project.IsDefined("HELIX_FEATURE_MP4_FILEFORMAT_M4A_ONLY"): + project.AddModuleLibraries("protocol/sdp[sdplib]", + "protocol/rtsp[rtsplib]", + "protocol/common/util[protutillib]", + "datatype/rm/common[rmcomlib]", + "datatype/amr/common[amrcomlib]") + ## Add h.263 renderer + if project.IsDefined("HELIX_FEATURE_VIDEO_H263"): + project.AddModuleLibraries("datatype/h263/payload[h263pyldlib]") + static_plugin_list[-1:-1] = ["h263render"] + ## Add MPEG4 renderer +# if project.IsDefined("HELIX_FEATURE_VIDEO_MPEG4"): +# static_plugin_list[-1:-1] = ["mp4xrender"] + ## Add mpeg 4 audio renderer + if project.IsDefined("HELIX_FEATURE_AUDIO_MPEG4"): + static_plugin_list[-1:-1] = ["mp4arender"] + project.AddModuleLibraries("datatype/mp4/audio/renderer[mp4arenderlib]") + if not project.IsDefined("HELIX_FEATURE_MP4_FILEFORMAT_M4A_ONLY"): + project.AddModuleLibraries("datatype/amr/common[amrcomlib]") + ## Add RV10 codec + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV10"): + project.AddLibraries(GetSDKPath("rv1dec_libs")+"[rv10lib]", + GetSDKPath("rv1dec_libs")+"[drv1lib]") + static_plugin_list[-1:-1] = ["rv10", "drv1"] + ## Add RV20 codec + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV20"): + project.AddLibraries(GetSDKPath("rvg2dec_libs")+"[rv20lib]", + GetSDKPath("rvg2dec_libs")+"[drv2lib]") + static_plugin_list[-1:-1] = ["rv20", "drv2"] + + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30") or \ + project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"): + static_plugin_list[-1:-1] = ["drvc"] + if project.IsDefined("HELIX_FEATURE_ANSIC_RV89COMBO"): + project.AddLibraries(GetSDKPath("rv89combo_c_libs")+"[drvc]") + else: + project.AddLibraries(GetSDKPath("rv89combo_libs")+"[drvclib]") + + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30"): + static_plugin_list[-1:-1] = ["rv30"] + project.AddLibraries(GetSDKPath("rv89combo_libs")+"[rv3xlib]") + project.AddModuleLibraries("datatype/rm/video/codec/rv89combo[rv30]") + + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"): + static_plugin_list[-1:-1] = ["rv40"] + project.AddLibraries(GetSDKPath("rv89combo_libs")+"[rv4xlib]") + project.AddModuleLibraries("datatype/rm/video/codec/rv89combo[rv40]") + +# if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_AAC"): +# static_plugin_list[-1:-1] = ["aac4"] + + CreateStaticPluginTable(static_plugin_list) + +project.ExportFunction("init_main", "void") +project.ExportFunction("deinit_main", "void") +project.ExportFunction("get_player", "void **ppPlayer", + "on_buffering_cb_t on_buffering_cb", + "on_pos_length_cb_t on_pos_length_cb") +project.ExportFunction("player_openurl", "void *pPlayerHandle", + "char *pszRawURL") +project.ExportFunction("put_player", "void *pPlayerHandle") +project.ExportFunction("player_geturl", "void *pPlayerHandle", "char **pszURL") +project.ExportFunction("player_begin", "void *pPlayerHandle") +project.ExportFunction("player_stop", "void *pPlayerHandle") +project.ExportFunction("player_pause", "void *pPlayerHandle") +project.ExportFunction("player_seek", "void *pPlayerHandle", "int pos") +project.ExportFunction("get_curr_playtime", "void *pPlayerHandle") +project.ExportFunction("player_getvolume", "void *pPlayerHandle") +project.ExportFunction("player_canseek", "void *pPlayerHandle") +project.ExportFunction("player_setvolume", "void *pPlayerHandle", "unsigned short volumn") + + + +DLLTarget('libhelix-player') + +DependTarget() + Index: helix-libs/clientapps/clutter/exabd.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exabd.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,245 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include + +#include "hxtypes.h" + +#include "hxcom.h" +#include "hxcomm.h" +#include "hxmon.h" +#include "hxcore.h" +#include "hxengin.h" +#include "chxpckts.h" +#include "hxclsnk.h" +#include "hxstrutl.h" +#include "exabd.h" + +#include "print.h" + +#include "globals.h" + +struct _stGlobals*& GetGlobal(); //in main.cpp + +ExampleABD::ExampleABD(IUnknown* pUnknown) + : m_lRefCount (0) + , m_pUnknown (NULL) + , m_ulABDStartTime(0) + , m_ulABDResult(0) + , m_bABDDone(FALSE) +{ + if (pUnknown) + { + m_pUnknown = pUnknown; + m_pUnknown->AddRef(); + } +} + +ExampleABD::~ExampleABD(void) +{ + HX_RELEASE(m_pUnknown); +} + + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::QueryInterface +// Purpose: +// Implement this to export the interfaces supported by your +// object. +// +STDMETHODIMP ExampleABD::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXAutoBWCalibrationAdviseSink*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXAutoBWCalibrationAdviseSink)) + { + AddRef(); + *ppvObj = (IHXAutoBWCalibrationAdviseSink*)this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::AddRef +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleABD::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::Release +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleABD::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + +/* + * IHXAutoBWCalibrationAdviseSink methods + */ +STDMETHODIMP +ExampleABD::AutoBWCalibrationStarted (const char* pszServer) +{ + if (pszServer) + { + STDOUT("ABD: contacting %s\n", pszServer); + } + + return HXR_OK; +} + +STDMETHODIMP +ExampleABD::AutoBWCalibrationDone(HX_RESULT status, + UINT32 ulBW) +{ + m_bABDDone = TRUE; + + if (HXR_OK == status) + { + m_ulABDResult = ulBW; + STDOUT("ABD: %lu(Kbps) %lu(ms)\n", ulBW, GetTickCount() - m_ulABDStartTime); + } + else + { + STDOUT("ABD failed: %lu\n", status); + } + + return HXR_OK; +} + +HX_RESULT +ExampleABD::DoABD(const char* pszServer, + UINT32 mode, + UINT32 packetSize, + UINT32 packetNum) +{ + HX_RESULT rc = HXR_OK; + UINT32 length = 0; + IHXAutoBWCalibration* pABD = NULL; + IHXValues* pValues = NULL; + IHXBuffer* pBuffer = NULL; + + m_ulABDStartTime = GetTickCount(); + m_ulABDResult = 0; + m_bABDDone = FALSE; + + if (m_pUnknown && + HXR_OK == m_pUnknown->QueryInterface(IID_IHXAutoBWCalibration, (void**)&pABD)) + { + pValues = (IHXValues*) new CHXHeader(); + pValues->AddRef(); + + pBuffer = (IHXBuffer*) new CHXBuffer(); + pBuffer->AddRef(); + + pBuffer->Set((UCHAR*)pszServer, strlen(pszServer)+1); + pValues->SetPropertyCString("ABDServers", pBuffer); + + pValues->SetPropertyULONG32("AutoBWDetectionMode", mode); + pValues->SetPropertyULONG32("AutoBWDetectionPacketSize", packetSize); + pValues->SetPropertyULONG32("AutoBWDetectionPackets", packetNum); + + pABD->AddAutoBWCalibrationSink((IHXAutoBWCalibrationAdviseSink*)this); + pABD->InitAutoBWCalibration(pValues); + + pABD->StartAutoBWCalibration(); + + while (!m_bABDDone) + { + MSG msg; + DWORD starttime, endtime, i; + BOOL sleep = TRUE; + static const int checkinterval = 10; + + starttime = GetTickCount(); + endtime = starttime + (20); + i = 0; + while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) + { + DispatchMessage(&msg); + if ((i % checkinterval) == 0) + { + if (GetTickCount() > endtime) + break; + ++i; + } + sleep = FALSE; + } + + if (sleep) + Sleep(10); + } + } + +cleanup: + + if (pABD) + { + pABD->RemoveAutoBWCalibrationSink((IHXAutoBWCalibrationAdviseSink*)this); + } + + HX_RELEASE(pBuffer); + HX_RELEASE(pValues); + HX_RELEASE(pABD); + + return rc; +} + + Index: helix-libs/clientapps/clutter/exabd.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exabd.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,85 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXAMPLEABD_ +#define _EXAMPLEABD_ + +struct IHXAutoBWCalibrationAdviseSink; +struct IUnknown; + +class ExampleABD : public IHXAutoBWCalibrationAdviseSink +{ + private: + LONG32 m_lRefCount; + IUnknown* m_pUnknown; + UINT32 m_ulABDStartTime; + UINT32 m_ulABDResult; + BOOL m_bABDDone; + + ~ExampleABD(); + + public: + + ExampleABD(IUnknown* /*IN*/ pUnknown); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXAutoBWCalibrationAdviseSink methods + */ + STDMETHOD(AutoBWCalibrationStarted) (THIS_ + const char* pszServer); + STDMETHOD(AutoBWCalibrationDone) (THIS_ + HX_RESULT status, + UINT32 ulBW); + + HX_RESULT DoABD(const char* pszServer, + UINT32 mode, + UINT32 packetSize, + UINT32 packetNum); + + UINT32 GetABD(void) { return m_ulABDResult; }; +}; + +#endif /* _EXAMPLEABDSNK_ */ Index: helix-libs/clientapps/clutter/exadvsnk.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exadvsnk.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,1116 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include + +#include "hxtypes.h" + +#include "hxcom.h" +#include "hxcomm.h" +#include "hxmon.h" +#include "hxcore.h" +#include "hxengin.h" +#include "hxclsnk.h" +#include "hxgroup.h" +#include "hxstrutl.h" +#include "exadvsnk.h" +#include "hxstring.h" +#include "hxprefs.h" +#include "excontxt.h" + +#include "print.h" + +#include "globals.h" +#include "player.h" + +struct _stGlobals*& GetGlobal(); //in main.cpp + +#ifdef __TCS__ +extern unsigned long gStreamTime; + +static int iOpened = 0; + + +#if defined(__cplusplus) +extern "C" { +#endif /* defined(__cplusplus) */ + +typedef enum hookBuffering { + eContacting = 0, + eConnecting = 1, + eBuffering = 2, + ePlaying = 3 +}hookBuffering; + +void hookRealAudio_Buffering(hookBuffering connectState, int pct); + +void hookRealAudio_PlayPosition(unsigned long current,unsigned long duration); + +typedef enum hookState { + ePlay = 0, + ePause = 1, + eStop = 2, + eResume = 3, + eComplete // Clip is done playing +}hookState; +void hookRealAudio_State(hookState newState); + + +#if defined(__cplusplus) +} +#endif /* defined(__cplusplus) */ + +#endif // __TCS__ + +void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes); + +ExampleClientAdviceSink::ExampleClientAdviceSink(IUnknown* pUnknown, LONG32 lClientIndex, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, void *context) + : m_lRefCount (0) + , m_lClientIndex (lClientIndex) + , m_pUnknown (NULL) + , m_pRegistry (NULL) + , m_pScheduler (NULL) + , m_lCurrentBandwidth(0) + , m_lAverageBandwidth(0) + , m_bOnStop(0) + , m_pPlayer(0) + , m_bWaitForTrackStart(0) + , m_on_buffering_cb(on_buffering_cb) + , m_on_pos_length_cb(on_pos_length_cb) + , m_context(context) +{ + if (pUnknown) + { + m_pUnknown = pUnknown; + m_pUnknown->AddRef(); + + if (HXR_OK != m_pUnknown->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry)) + { + m_pRegistry = NULL; + } + + if (HXR_OK != m_pUnknown->QueryInterface(IID_IHXScheduler, (void**)&m_pScheduler)) + { + m_pScheduler = NULL; + } + + IHXPlayer* pPlayer; + if(HXR_OK == m_pUnknown->QueryInterface(IID_IHXPlayer, + (void**)&pPlayer)) + { + m_pPlayer = pPlayer; + + IHXGroupManager* pGroupMgr = NULL; + if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, + (void**)&pGroupMgr)) + { + pGroupMgr->AddSink((IHXGroupSink*)this); + pGroupMgr->Release(); + } + + pPlayer->AddAdviseSink(this); + + } + } + +#ifdef __TCS__ + bEnableAdviceSink = TRUE; + iOpened = 0; +#endif +} + +ExampleClientAdviceSink::~ExampleClientAdviceSink(void) +{ + if (m_pScheduler) + { + m_pScheduler->Release(); + m_pScheduler = NULL; + } + + if (m_pRegistry) + { + m_pRegistry->Release(); + m_pRegistry = NULL; + } + + if (m_pPlayer) + { + m_pPlayer->Release(); + m_pPlayer = NULL; + } + if (m_pUnknown) + { + m_pUnknown->Release(); + m_pUnknown = NULL; + } +} + + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::QueryInterface +// Purpose: +// Implement this to export the interfaces supported by your +// object. +// +STDMETHODIMP ExampleClientAdviceSink::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXClientAdviseSink*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXClientAdviseSink)) + { + AddRef(); + *ppvObj = (IHXClientAdviseSink*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXGroupSink)) + { + AddRef(); + *ppvObj = (IHXGroupSink*)this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::AddRef +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientAdviceSink::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::Release +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientAdviceSink::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + +/* + * IHXClientAdviseSink methods + */ + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPosLength + * Purpose: + * Called to advise the client that the position or length of the + * current playback context has changed. + */ + +#ifdef __TCS__ +static long lastPosition = -1; +#endif + +STDMETHODIMP +ExampleClientAdviceSink::OnPosLength(UINT32 ulPosition, + UINT32 ulLength) +{ + // Are we doing a multi-seek? + if (GetGlobal()->g_bMultiSeek) + { + // Have we run out of seek times? + if (GetGlobal()->g_ulMultiSeekIndex < GetGlobal()->g_ulNumMultiSeeks) + { + STDOUT("Multi-seeking the first player to %lu\n", + GetGlobal()->g_ulMultiSeekTime[GetGlobal()->g_ulMultiSeekIndex]); + GetGlobal()->g_Players[0]->Seek(GetGlobal()->g_ulMultiSeekTime[GetGlobal()->g_ulMultiSeekIndex++]); + } + else + { + // We've run out - stop the multi-seek + GetGlobal()->g_bMultiSeek = FALSE; + GetGlobal()->g_ulNumMultiSeeks = 0; + GetGlobal()->g_ulMultiSeekIndex = 0; + } + } + + if (m_on_pos_length_cb) + m_on_pos_length_cb(ulPosition, ulLength, m_context); + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPresentationOpened + * Purpose: + * Called to advise the client a presentation has been opened. + */ +STDMETHODIMP ExampleClientAdviceSink::OnPresentationOpened() +{ +#ifdef __TCS__ + iOpened = 1; + lastPosition = -1; +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnPresentationOpened()\n"); + } +#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) + // Try to get the IHXPlaybackVelocity interface + // from the first player + if (GetGlobal()->g_nPlayers > 0 && GetGlobal()->g_Players[0]) + { + IHXPlaybackVelocity* pVel = NULL; + HX_RESULT rv = GetGlobal()->g_Players[0]->QueryInterface(IID_IHXPlaybackVelocity, (void**) &pVel); + if (SUCCEEDED(rv)) + { + // Get the capabilities object from the player + rv = pVel->QueryVelocityCaps(GetGlobal()->g_pVelocityCaps); + if (SUCCEEDED(rv) && GetGlobal()->bEnableAdviceSink) + { + STDOUT("Available Velocity Ranges:"); + UINT32 ulNumRanges = GetGlobal()->g_pVelocityCaps->GetNumRanges(); + for (UINT32 i = 0; i < ulNumRanges && SUCCEEDED(rv); i++) + { + INT32 lMin = 0; + INT32 lMax = 0; + rv = GetGlobal()->g_pVelocityCaps->GetRange(i, lMin, lMax); + if (SUCCEEDED(rv)) + { + STDOUT(" [%ld,%ld]", lMin, lMax); + } + } + STDOUT("\n"); + } + } + HX_RELEASE(pVel); + } +#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */ +#endif + + UINT32 sourceCount = m_pPlayer->GetSourceCount(); + for (UINT32 sourceID = 0; sourceID < sourceCount; sourceID ++) + { + // get HXSource + IUnknown* pUnkSource = NULL; + IHXStreamSource* pStreamSrc = NULL; + + if (HXR_OK != m_pPlayer->GetSource (sourceID, pUnkSource)) + { + continue; + } + + pUnkSource->QueryInterface(IID_IHXStreamSource, (void **)&pStreamSrc); + + HX_RELEASE(pUnkSource); + + if (!pStreamSrc) + { + continue; + } + + UINT32 num_streams = pStreamSrc->GetStreamCount(); + + // get information from Streams + for (UINT32 streamID = 0; streamID < num_streams ; streamID++) + { + IUnknown* pUnkStream = NULL; + + if (HXR_OK == pStreamSrc->GetStream(streamID, pUnkStream)) + { + IHXStream* pStream = NULL; + + if (HXR_OK == pUnkStream->QueryInterface(IID_IHXStream, + (void**)&pStream)) + { + const char* pMimeType = pStream->GetStreamType(); + if( 0 == strcmp(pMimeType, "application/ram")) + { + m_bWaitForTrackStart = TRUE; + } + else + { + m_bWaitForTrackStart = FALSE; + } + } + HX_RELEASE(pStream); + } + HX_RELEASE(pUnkStream); + if (!m_bWaitForTrackStart) + { + break; + } + } + + if (!m_bWaitForTrackStart) + { + break; + } + HX_RELEASE(pStreamSrc); + } + + if (!m_bWaitForTrackStart) + { + STDOUT("----------------clip info--------------------\n"); + if(m_pScheduler) { + m_hCallback = m_pScheduler->RelativeEnter(this,50); + } + } + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPresentationClosed + * Purpose: + * Called to advise the client a presentation has been closed. + */ +STDMETHODIMP ExampleClientAdviceSink::OnPresentationClosed() +{ +#ifdef __TCS__ + iOpened = 0; + lastPosition = -1; +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnPresentationClosed()\n"); + } +#endif + + return HXR_OK; +} + +void ExampleClientAdviceSink::GetStatistics (char* pszRegistryKey) +{ + char szRegistryValue[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */ + INT32 lValue = 0; + INT32 i = 0; + INT32 lStatistics = 8; + UINT32 *plValue; + +#ifdef __TCS__ + return; // DISABLED FOR NOW +#endif + + // collect statistic + for (i = 0; i < lStatistics; i++) + { + plValue = NULL; + switch (i) + { + case 0: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Normal", pszRegistryKey); + break; + case 1: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Recovered", pszRegistryKey); + break; + case 2: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Received", pszRegistryKey); + break; + case 3: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Lost", pszRegistryKey); + break; + case 4: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Late", pszRegistryKey); + break; + case 5: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.ClipBandwidth", pszRegistryKey); + break; + case 6: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.AverageBandwidth", pszRegistryKey); + plValue = &m_lAverageBandwidth; + break; + case 7: + SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.CurrentBandwidth", pszRegistryKey); + plValue = &m_lCurrentBandwidth; + break; + default: + break; + } + + m_pRegistry->GetIntByName(szRegistryValue, lValue); + if (plValue) + { + if (m_bOnStop || lValue == 0) + { + lValue = *plValue; + } + else + { + *plValue = lValue; + } + } + if (GetGlobal()->bEnableAdviceSink || (GetGlobal()->bEnableVerboseMode && m_bOnStop)) + { + STDOUT("%s = %ld\n", szRegistryValue, lValue); + } + } +} + +void ExampleClientAdviceSink::GetAllStatistics(void) +{ + UINT32 unPlayerIndex = 0; + UINT32 unSourceIndex = 0; + UINT32 unStreamIndex = 0; + + char* pszRegistryPrefix = "Statistics"; + char szRegistryName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */ + +#ifdef __TCS__ + return; // DISABLED FOR NOW +#endif + + // display the content of whole statistic registry + if (m_pRegistry) + { + // ok, let's start from the top (player) + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", pszRegistryPrefix, m_lClientIndex); + if (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName)) + { + // display player statistic + GetStatistics(szRegistryName); + + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Source%ld", szRegistryName, unSourceIndex); + while (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName)) + { + // display source statistic + GetStatistics(szRegistryName); + + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Stream%ld", szRegistryName, unStreamIndex); + while (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName)) + { + // display stream statistic + GetStatistics(szRegistryName); + + unStreamIndex++; + + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld.Stream%ld", + pszRegistryPrefix, unPlayerIndex, unSourceIndex, unStreamIndex); + } + + unSourceIndex++; + + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld", + pszRegistryPrefix, unPlayerIndex, unSourceIndex); + } + + unPlayerIndex++; + + SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", pszRegistryPrefix, unPlayerIndex); + } + } +} + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnStatisticsChanged + * Purpose: + * Called to advise the client that the presentation statistics + * have changed. + */ +STDMETHODIMP ExampleClientAdviceSink::OnStatisticsChanged(void) +{ + char szBuff[1024]; /* Flawfinder: ignore */ + HX_RESULT res = HXR_OK; + UINT16 uPlayer = 0; + +#ifdef __TCS__ + return HXR_OK; // DISABLED FOR NOW +#endif + + if(GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnStatisticsChanged():\n"); + + SafeSprintf(szBuff, 1024, "Statistics"); + res = DumpRegTree( szBuff ); + } + + return HXR_OK; +} + +HX_RESULT ExampleClientAdviceSink::DumpRegTree(const char* pszTreeName ) +{ + const char* pszName = NULL; + ULONG32 ulRegID = 0; + HX_RESULT res = HXR_OK; + INT32 nVal = 0; + IHXBuffer* pBuff = NULL; + IHXValues* pValues = NULL; + + //See if the name exists in the reg tree. + res = m_pRegistry->GetPropListByName( pszTreeName, pValues); + if( HXR_OK!=res || !pValues ) + return HXR_FAIL; + + //make sure this is a PT_COMPOSITE type reg entry. + if( PT_COMPOSITE != m_pRegistry->GetTypeByName(pszTreeName)) + return HXR_FAIL; + + //Print out the value of each member of this tree. + res = pValues->GetFirstPropertyULONG32( pszName, ulRegID ); + while( HXR_OK == res ) + { + //We have at least one entry. See what type it is. + HXPropType pt = m_pRegistry->GetTypeById(ulRegID); + switch(pt) + { + case PT_COMPOSITE: + DumpRegTree(pszName); + break; + case PT_INTEGER : + nVal = 0; + m_pRegistry->GetIntById( ulRegID, nVal ); + STDOUT("%s : %d\n", pszName, nVal ); + break; + case PT_INTREF : + nVal = 0; + m_pRegistry->GetIntById( ulRegID, nVal ); + STDOUT("%s : %d\n", pszName, nVal ); + break; + case PT_STRING : + pBuff = NULL; + m_pRegistry->GetStrById( ulRegID, pBuff ); + STDOUT("%s : \"", pszName ); + if( pBuff ) + STDOUT("%s", (const char *)(pBuff->GetBuffer()) ); + STDOUT("\"\n" ); + HX_RELEASE(pBuff); + break; + case PT_BUFFER : + STDOUT("%s : BUFFER TYPE NOT SHOWN\n", + pszName, nVal ); + break; + case PT_UNKNOWN: + STDOUT("%s Unkown registry type entry\n", pszName ); + break; + default: + STDOUT("%s Unkown registry type entry\n", pszName ); + break; + } + res = pValues->GetNextPropertyULONG32( pszName, ulRegID); + } + + HX_RELEASE( pValues ); + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPreSeek + * Purpose: + * Called by client engine to inform the client that a seek is + * about to occur. The render is informed the last time for the + * stream's time line before the seek, as well as the first new + * time for the stream's time line after the seek will be completed. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnPreSeek( ULONG32 ulOldTime, + ULONG32 ulNewTime) +{ +#if !defined(__TCS__) + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnPreSeek(%ld, %ld)\n", ulOldTime, ulNewTime); + } +#endif + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPostSeek + * Purpose: + * Called by client engine to inform the client that a seek has + * just occured. The render is informed the last time for the + * stream's time line before the seek, as well as the first new + * time for the stream's time line after the seek. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnPostSeek( ULONG32 ulOldTime, + ULONG32 ulNewTime) +{ +#ifdef __TCS__ + lastPosition = -1; +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnPostSeek(%ld, %ld)\n", ulOldTime, ulNewTime); + } +#endif + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnStop + * Purpose: + * Called by client engine to inform the client that a stop has + * just occured. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnStop(void) +{ + HXTimeval now; + +#ifdef __TCS__ + hookRealAudio_State(eStop); +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnStop()\n"); + } + + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("Player %ld stopped.\n", m_lClientIndex); + m_bOnStop = TRUE; + GetAllStatistics(); + } +#endif + + // Find out the current time and subtract the beginning time to + // figure out how many seconds we played + now = m_pScheduler->GetCurrentSchedulerTime(); + m_ulStopTime = now.tv_sec; + + GetGlobal()->g_ulNumSecondsPlayed = m_ulStopTime - m_ulStartTime; + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnPause + * Purpose: + * Called by client engine to inform the client that a pause has + * just occured. The render is informed the last time for the + * stream's time line before the pause. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnPause(ULONG32 ulTime) +{ +#ifdef __TCS__ + hookRealAudio_State(ePause); +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnPause(%ld)\n", ulTime); + } +#endif + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnBegin + * Purpose: + * Called by client engine to inform the client that a begin or + * resume has just occured. The render is informed the first time + * for the stream's time line after the resume. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnBegin(ULONG32 ulTime) +{ + HXTimeval now; + +#if !defined(__TCS__) + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnBegin(%ld)\n", ulTime); + } + + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("Player %ld beginning playback...\n", m_lClientIndex); + } +#endif + + GetGlobal()->g_bOnBeginOccurred = TRUE; + + // Record the current time, so we can figure out many seconds we played + now = m_pScheduler->GetCurrentSchedulerTime(); + m_ulStartTime = now.tv_sec; + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnBuffering + * Purpose: + * Called by client engine to inform the client that buffering + * of data is occuring. The render is informed of the reason for + * the buffering (start-up of stream, seek has occured, network + * congestion, etc.), as well as percentage complete of the + * buffering process. + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnBuffering(ULONG32 ulFlags, + UINT16 unPercentComplete) +{ +#ifdef __TCS__ +static UINT16 lastPct = 0; + if (unPercentComplete > 0) + { + UINT16 nextPct = lastPct + 10; + if (unPercentComplete < lastPct) + { + lastPct = 0; + nextPct = lastPct + 10; + } + if (unPercentComplete >= nextPct) + { + lastPct = (unPercentComplete / 10) * 10; + nextPct = lastPct + 10; + hookRealAudio_Buffering(eBuffering,lastPct); + } + } +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnBuffering(%ld, %d)\n", ulFlags, unPercentComplete); + } +#endif + if (m_on_buffering_cb) + m_on_buffering_cb(ulFlags, unPercentComplete, m_context); + + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXClientAdviseSink::OnContacting + * Purpose: + * Called by client engine to inform the client is contacting + * hosts(s). + * + */ +STDMETHODIMP ExampleClientAdviceSink::OnContacting(const char* pHostName) +{ +#ifdef __TCS__ + printf("Contacting\n"); + hookRealAudio_Buffering(eContacting,0); +#else + if (GetGlobal()->bEnableAdviceSink) + { + STDOUT("OnContacting(\"%s\")\n", pHostName); + } +#endif + + return HXR_OK; +} + +void ExampleClientAdviceSink::PrintPropName( IHXValues* pHeader ) +{ + if ( pHeader == NULL ) + { + return ; + } + + const char *pChar; + ULONG32 pValue; + if(HXR_OK == pHeader->GetFirstPropertyULONG32(pChar, pValue)) + { + do + { + STDOUT("%s %d\n", pChar, pValue); + } + while(HXR_OK == pHeader->GetNextPropertyULONG32(pChar, pValue)); + } + + IHXBuffer *pBuffer; + + if(HXR_OK == pHeader->GetFirstPropertyBuffer(pChar, pBuffer)) + { + do + { + STDOUT("%s %s\n", pChar, (const char *) ( pBuffer->GetBuffer() )); + PrintBuffer(pChar, pBuffer->GetBuffer() ,pBuffer->GetSize()); + HX_RELEASE(pBuffer); + } while(HXR_OK == pHeader->GetNextPropertyBuffer(pChar, pBuffer )); + } + + if(HXR_OK == pHeader->GetFirstPropertyCString(pChar, pBuffer)) + { + do + { + STDERR("%s %s\n", pChar, (const char *) ( pBuffer->GetBuffer() )); + HX_RELEASE(pBuffer); + } while(HXR_OK == pHeader->GetNextPropertyCString(pChar, pBuffer )); + } + + fflush(stdout); +} + + +void ExampleClientAdviceSink::SetClipInfo( IHXPlayer* m_pRMAPlayer) +{ + bool bSendOnClipInfo = false; + + // Get HXSource and try to get clip infor. + UINT32 sourceCount = m_pRMAPlayer->GetSourceCount(); + for (UINT32 sourceID = 0; sourceID < sourceCount; sourceID ++) + { + // get HXSource + STDOUT("========Source %d========\n",sourceID); + IUnknown* pUnkSource = NULL; + IHXStreamSource* pStreamSrc = NULL; + + if (HXR_OK != m_pRMAPlayer->GetSource (sourceID, pUnkSource)) + { + continue; + } + + pUnkSource->QueryInterface(IID_IHXStreamSource, (void **)&pStreamSrc); + + HX_RELEASE(pUnkSource); + + if (!pStreamSrc) + { + continue; + } + + UINT32 num_streams = pStreamSrc->GetStreamCount(); + + STDOUT("====File Header====\n"); + + IHXValues* pFileHdr = NULL; + pStreamSrc->QueryInterface(IID_IHXValues, (void**)&pFileHdr); + + if ( pFileHdr) + { + PrintPropName(pFileHdr); + } + HX_RELEASE(pFileHdr); + + // get information from Streams + for (UINT32 streamID = 0; streamID < num_streams ; streamID++) + { + STDOUT("====Stream %d====\n",streamID); + IUnknown* pUnkStream = NULL; + + if (HXR_OK == pStreamSrc->GetStream(streamID, pUnkStream)) + { + IHXStream* pStream = NULL; + + if (HXR_OK == pUnkStream->QueryInterface(IID_IHXStream, + (void**)&pStream)) + { + IHXValues* pStreamHdr = pStream->GetHeader(); + if (pStreamHdr) + { + PrintPropName(pStreamHdr); + } + HX_RELEASE(pStreamHdr); + } + HX_RELEASE(pStream); + } + HX_RELEASE(pUnkStream); + } + STDOUT("---------------------------------------------\n"); + + HX_RELEASE(pStreamSrc); + } +} + + +STDMETHODIMP ExampleClientAdviceSink::Func() +{ + m_hCallback = 0; + + // set clip info + if(m_pPlayer) + SetClipInfo(m_pPlayer); + + return HXR_OK; +} + +void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes) +{ + if(pszName == NULL || pbBuf == NULL) + return; + + STDOUT(" "); + for(unsigned int i= 0; iRelativeEnter(this,50); + } + m_bWaitForTrackStart = FALSE; + } + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXGroupSink::TrackStopped + * Purpose: + * Notification of a track being stopped + * + */ +STDMETHODIMP ExampleClientAdviceSink::TrackStopped( UINT16 /*IN*/ uGroupIndex, + UINT16 /*IN*/ uTrackIndex, + IHXValues* /*IN*/ pTrack) +{ + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXGroupSink::CurrentGroupSet + * Purpose: + * This group is being currently played in the presentation. + */ +STDMETHODIMP ExampleClientAdviceSink::CurrentGroupSet( UINT16 /*IN*/ uGroupIndex, + IHXGroup* /*IN*/ pGroup) +{ + return HXR_OK; +} + Index: helix-libs/clientapps/clutter/exadvsnk.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exadvsnk.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,324 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXAMPLECLSNK_ +#define _EXAMPLECLSNK_ + +#include "player.h" + +struct IHXClientAdviseSink; +struct IHXGroupSink; +struct IUnknown; +struct IHXRegistry; +struct IHXScheduler; +struct IHXCallback; +struct IHXPlayer; +struct IHXGroup; + +class ExampleClientAdviceSink : public IHXClientAdviseSink, + public IHXGroupSink, + public IHXCallback +{ + private: + LONG32 m_lRefCount; + LONG32 m_lClientIndex; + + IUnknown* m_pUnknown; + IHXRegistry* m_pRegistry; + IHXScheduler* m_pScheduler; + + UINT32 m_ulStartTime; + UINT32 m_ulStopTime; + + UINT32 m_lCurrentBandwidth; + UINT32 m_lAverageBandwidth; + HXBOOL m_bOnStop; + + HXBOOL m_bWaitForTrackStart; + + on_buffering_cb_t m_on_buffering_cb; + on_pos_length_cb_t m_on_pos_length_cb; + void *m_context; /* a argument passed by texture-helix lib */ + + // IHXCallback + IHXPlayer* m_pPlayer; + ULONG32 m_hCallback; + ~ExampleClientAdviceSink(); + HX_RESULT DumpRegTree(const char* pszTreeName ); + + + void GetStatistics (char* /*IN*/ pszRegistryKey); + void GetAllStatistics (void); + void SetClipInfo( IHXPlayer* m_pRMAPlayer); + void PrintPropName( IHXValues* pHeader ); + + public: + + ExampleClientAdviceSink(IUnknown* /*IN*/ pUnknown, LONG32 /*IN*/ lClientIndex, on_buffering_cb_t on_buffer_cb, on_pos_length_cb_t on_pos_length_cb, void *context); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXClientAdviseSink methods + */ + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPosLength + * Purpose: + * Called to advise the client that the position or length of the + * current playback context has changed. + */ + STDMETHOD(OnPosLength) (THIS_ + UINT32 ulPosition, + UINT32 ulLength); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPresentationOpened + * Purpose: + * Called to advise the client a presentation has been opened. + */ + STDMETHOD(OnPresentationOpened) (THIS); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPresentationClosed + * Purpose: + * Called to advise the client a presentation has been closed. + */ + STDMETHOD(OnPresentationClosed) (THIS); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnStatisticsChanged + * Purpose: + * Called to advise the client that the presentation statistics + * have changed. + */ + STDMETHOD(OnStatisticsChanged) (THIS); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPreSeek + * Purpose: + * Called by client engine to inform the client that a seek is + * about to occur. The render is informed the last time for the + * stream's time line before the seek, as well as the first new + * time for the stream's time line after the seek will be completed. + * + */ + STDMETHOD (OnPreSeek) (THIS_ + ULONG32 ulOldTime, + ULONG32 ulNewTime); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPostSeek + * Purpose: + * Called by client engine to inform the client that a seek has + * just occured. The render is informed the last time for the + * stream's time line before the seek, as well as the first new + * time for the stream's time line after the seek. + * + */ + STDMETHOD (OnPostSeek) (THIS_ + ULONG32 ulOldTime, + ULONG32 ulNewTime); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnStop + * Purpose: + * Called by client engine to inform the client that a stop has + * just occured. + * + */ + STDMETHOD (OnStop) (THIS); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnPause + * Purpose: + * Called by client engine to inform the client that a pause has + * just occured. The render is informed the last time for the + * stream's time line before the pause. + * + */ + STDMETHOD (OnPause) (THIS_ + ULONG32 ulTime); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnBegin + * Purpose: + * Called by client engine to inform the client that a begin or + * resume has just occured. The render is informed the first time + * for the stream's time line after the resume. + * + */ + STDMETHOD (OnBegin) (THIS_ + ULONG32 ulTime); + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnBuffering + * Purpose: + * Called by client engine to inform the client that buffering + * of data is occuring. The render is informed of the reason for + * the buffering (start-up of stream, seek has occured, network + * congestion, etc.), as well as percentage complete of the + * buffering process. + * + */ + STDMETHOD (OnBuffering) (THIS_ + ULONG32 ulFlags, + UINT16 unPercentComplete); + + + /************************************************************************ + * Method: + * IHXClientAdviseSink::OnContacting + * Purpose: + * Called by client engine to inform the client is contacting + * hosts(s). + * + */ + STDMETHOD (OnContacting) (THIS_ + const char* pHostName); + + // IHXCallback + STDMETHOD(Func) (THIS); + + /* + * IHXGroupSink methods + */ + /************************************************************************ + * Method: + * IHXGroupSink::GroupAdded + * Purpose: + * Notification of a new group being added to the presentation. + */ + STDMETHOD(GroupAdded) (THIS_ + UINT16 /*IN*/ uGroupIndex, + IHXGroup* /*IN*/ pGroup); + + /************************************************************************ + * Method: + * IHXGroupSink::GroupRemoved + * Purpose: + * Notification of a group being removed from the presentation. + */ + STDMETHOD(GroupRemoved) (THIS_ + UINT16 /*IN*/ uGroupIndex, + IHXGroup* /*IN*/ pGroup); + + /************************************************************************ + * Method: + * IHXGroupSink::AllGroupsRemoved + * Purpose: + * Notification that all groups have been removed from the + * current presentation. + */ + STDMETHOD(AllGroupsRemoved) (THIS); + + /************************************************************************ + * Method: + * IHXGroupSink::TrackAdded + * Purpose: + * Notification of a new track being added to a group. + */ + STDMETHOD(TrackAdded) (THIS_ + UINT16 /*IN*/ uGroupIndex, + UINT16 /*IN*/ uTrackIndex, + IHXValues* /*IN*/ pTrack); + + /************************************************************************ + * Method: + * IHXGroupSink::TrackRemoved + * Purpose: + * Notification of a track being removed from a group. + */ + STDMETHOD(TrackRemoved) (THIS_ + UINT16 /*IN*/ uGroupIndex, + UINT16 /*IN*/ uTrackIndex, + IHXValues* /*IN*/ pTrack); + + /************************************************************************ + * Method: + * IHXGroupSink::TrackStarted + * Purpose: + * Notification of a track being started (to get duration, for + * instance...) + */ + STDMETHOD (TrackStarted) (THIS_ + UINT16 /*IN*/ uGroupIndex, + UINT16 /*IN*/ uTrackIndex, + IHXValues* /*IN*/ pTrack) ; + + /************************************************************************ + * Method: + * IHXGroupSink::TrackStopped + * Purpose: + * Notification of a track being stopped + * + */ + STDMETHOD(TrackStopped) (THIS_ + UINT16 /*IN*/ uGroupIndex, + UINT16 /*IN*/ uTrackIndex, + IHXValues* /*IN*/ pTrack); + + /************************************************************************ + * Method: + * IHXGroupSink::CurrentGroupSet + * Purpose: + * This group is being currently played in the presentation. + */ + STDMETHOD(CurrentGroupSet) (THIS_ + UINT16 /*IN*/ uGroupIndex, + IHXGroup* /*IN*/ pGroup); + +}; + +#endif /* _EXAMPLECLSNK_ */ Index: helix-libs/clientapps/clutter/exaumgr.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exaumgr.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,137 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include +#include "hxtypes.h" +#include "hxcom.h" +#include "hxauth.h" +#include "hxstrutl.h" +#include "exaumgr.h" +#include +#include "print.h" + + +#include "globals.h" +struct _stGlobals*& GetGlobal(); //in main.cpp + + + +ExampleAuthenticationManager::ExampleAuthenticationManager() : + m_lRefCount(0), + m_bSentPassword(FALSE) +{ +} + +ExampleAuthenticationManager::~ExampleAuthenticationManager() +{ +} + +STDMETHODIMP +ExampleAuthenticationManager::QueryInterface(REFIID riid, void**ppvObj) +{ + if(IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXAuthenticationManager*)this; + return HXR_OK; + } + else if(IsEqualIID(riid, IID_IHXAuthenticationManager)) + { + AddRef(); + *ppvObj = (IHXAuthenticationManager*)this; + return HXR_OK; + } + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +STDMETHODIMP_(UINT32) +ExampleAuthenticationManager::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +STDMETHODIMP_(UINT32) +ExampleAuthenticationManager::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + +STDMETHODIMP +ExampleAuthenticationManager::HandleAuthenticationRequest(IHXAuthenticationManagerResponse* pResponse) +{ + char username[1024] = ""; /* Flawfinder: ignore */ + char password[1024] = ""; /* Flawfinder: ignore */ + HX_RESULT res = HXR_FAIL; + + if( !m_bSentPassword ) + { + res = HXR_OK; + if (GetGlobal()->bEnableVerboseMode) + STDOUT("\nSending Username and Password...\n"); + + SafeStrCpy(username, GetGlobal()->g_pszUsername, 1024); + SafeStrCpy(password, GetGlobal()->g_pszPassword, 1024); + + //strip trailing whitespace + char* c; + for(c = username + strlen(username) - 1; + c > username && isspace(*c); + c--) + ; + *(c+1) = 0; + + for(c = password + strlen(password) - 1; + c > password && isspace(*c); + c--) + ; + *(c+1) = 0; + + m_bSentPassword = TRUE; + } + + if (GetGlobal()->bEnableVerboseMode && FAILED(res) ) + STDOUT("\nInvalid Username and/or Password.\n"); + + pResponse->AuthenticationRequestDone(res, username, password); + return res; +} + Index: helix-libs/clientapps/clutter/exaumgr.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exaumgr.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,56 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXAUMGR_H_ +#define _EXAUMGR_H_ + +#include "hxauth.h" + +class ExampleAuthenticationManager : public IHXAuthenticationManager +{ +private: + INT32 m_lRefCount; + HXBOOL m_bSentPassword; + ~ExampleAuthenticationManager(); + +public: + ExampleAuthenticationManager(); + STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj); + STDMETHOD_(UINT32,AddRef) (THIS); + STDMETHOD_(UINT32,Release) (THIS); + + STDMETHOD(HandleAuthenticationRequest) (IHXAuthenticationManagerResponse* pResponse); +}; +#endif Index: helix-libs/clientapps/clutter/excallback.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/excallback.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,38 @@ +#include "excallback.h" + +STDMETHODIMP ExCallback::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IHXCallback)) + { + AddRef(); + *ppvObj = (IHXCallback*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +STDMETHODIMP_(ULONG32) ExCallback::AddRef() +{ + return HXR_OK; +} + +STDMETHODIMP_(ULONG32) ExCallback::Release() +{ + return HXR_OK; +} + +STDMETHODIMP ExCallback::Func(void) +{ + UINT32 sleepTime = 0; + m_pKicker->Kick(HXGetCurrentThreadID, &sleepTime); + printf("Get called, sleeptime:%d\n", sleepTime); + m_pScheduler->RelativeEnter(this, sleepTime/1000); +} Index: helix-libs/clientapps/clutter/excallback.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/excallback.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,32 @@ +#ifndef _EX_CALLBACK_H_ +#define _EX_CALLBACK_H_ + +#include "hxcom.h" +#include "hxengin.h" +#include "ihxmedpltfm.h" +#include "thrdutil.h" + +class ExCallback : public IHXCallback +{ + public: + ExCallback(IHXScheduler *pIHXScheduler, IHXMediaPlatformKicker *pKicker) : m_pScheduler(pIHXScheduler), m_pKicker(pKicker){}; + + /* + * * IUnknown methods + * */ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj); + STDMETHOD_(ULONG32,AddRef) (THIS); + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * * IHXCallback methods + * */ + STDMETHOD(Func) (THIS); + private: + IHXScheduler *m_pScheduler; + IHXMediaPlatformKicker* m_pKicker; + +}; + + +#endif Index: helix-libs/clientapps/clutter/excontxt.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/excontxt.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,315 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include "hxtypes.h" + +#include "hxwintyp.h" +#include "hxcom.h" +#include "hxcomm.h" +#include "hxwin.h" +#include "fivemmap.h" + +#include "hxbuffer.h" +#include "hxmangle.h" + +#include "hxclsnk.h" +#include "hxgroup.h" +#include "hxerror.h" +#include "hxprefs.h" +#include "hxstrutl.h" + +#include "exadvsnk.h" +#include "exstateadvsnk.h" +#include "exerror.h" +#include "exsitsup.h" +#include "exaumgr.h" +#include "hxprdnld.h" +#include "exprdnld.h" + +#include "excontxt.h" + +extern HXBOOL bEnableAdviceSink; + + +ExampleClientContext::ExampleClientContext(LONG32 lClientIndex) + : m_lRefCount(0) + , m_lClientIndex(lClientIndex) + , m_pClientSink(NULL) + , m_pClientStateSink(NULL) + , m_pErrorSink(NULL) + , m_pAuthMgr(NULL) + , m_pSiteSupplier(NULL) + , m_pDefaultPrefs(NULL) +#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS) + , m_pPrgDnldStatusObserver(NULL) +#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS. +{ +} + + +ExampleClientContext::~ExampleClientContext() +{ + Close(); +}; + +void ExampleClientContext::Init(IUnknown* /*IN*/ pUnknown, + IHXPreferences* /*IN*/ pPreferences, + char* /*IN*/ pszGUID, + on_buffering_cb_t on_buffering_cb, + on_pos_length_cb_t on_pos_length_cb, + on_state_change_cb_t on_state_change_cb, + on_new_frame_cb_t on_new_frame_cb, + void *context) +{ + char* pszCipher = NULL; + + + m_pClientSink = new ExampleClientAdviceSink(pUnknown, m_lClientIndex, on_buffering_cb, on_pos_length_cb, context); + + m_pClientStateSink = new ExampleClientStateAdviceSink(pUnknown, m_lClientIndex, on_state_change_cb, context); + m_pErrorSink = new ExampleErrorSink(pUnknown); +#if defined(HELIX_FEATURE_AUTHENTICATION) + m_pAuthMgr = new ExampleAuthenticationManager(); + if(m_pAuthMgr) + { + m_pAuthMgr->AddRef(); + } + +#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */ +#if defined(HELIX_FEATURE_VIDEO) + m_pSiteSupplier = new ExampleSiteSupplier(pUnknown, on_new_frame_cb, context); +#endif + +#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS) + m_pPrgDnldStatusObserver = new ExamplePDStatusObserver(pUnknown); +#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS. + + if (m_pClientSink) + { + m_pClientSink->AddRef(); + } + + if (m_pErrorSink) + { + m_pErrorSink->AddRef(); + } + + if (m_pClientStateSink) + m_pClientStateSink->AddRef(); + + if(m_pSiteSupplier) + { + m_pSiteSupplier->AddRef(); + } + + if (pPreferences) + { + m_pDefaultPrefs = pPreferences; + m_pDefaultPrefs->AddRef(); + } + + if (pszGUID && *pszGUID) + { + // Encode GUID + pszCipher = Cipher(pszGUID); + SafeStrCpy(m_pszGUID, pszCipher, 256); + } + else + { + m_pszGUID[0] = '\0'; + } +} + +void ExampleClientContext::Close() +{ + HX_RELEASE(m_pClientSink); + HX_RELEASE(m_pClientStateSink); + HX_RELEASE(m_pErrorSink); +#if defined(HELIX_FEATURE_AUTHENTICATION) + HX_RELEASE(m_pAuthMgr); +#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */ + HX_RELEASE(m_pSiteSupplier); + HX_RELEASE(m_pDefaultPrefs); +#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS) + HX_RELEASE(m_pPrgDnldStatusObserver); +#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS. +} + + + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::QueryInterface +// Purpose: +// Implement this to export the interfaces supported by your +// object. +// +STDMETHODIMP ExampleClientContext::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXPreferences)) + { + AddRef(); + *ppvObj = (IHXPreferences*)this; + return HXR_OK; + } + else if (m_pClientSink && + m_pClientSink->QueryInterface(riid, ppvObj) == HXR_OK) + { + return HXR_OK; + } + else if (m_pErrorSink && + m_pErrorSink->QueryInterface(riid, ppvObj) == HXR_OK) + { + return HXR_OK; + } + else if (m_pClientStateSink && + m_pClientStateSink->QueryInterface(riid, ppvObj) == HXR_OK) + { + return HXR_OK; + } +#if defined(HELIX_FEATURE_AUTHENTICATION) + else if(m_pAuthMgr && + m_pAuthMgr->QueryInterface(riid, ppvObj) == HXR_OK) + { + return HXR_OK; + } +#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */ + else if(m_pSiteSupplier && + m_pSiteSupplier->QueryInterface(riid, ppvObj) == HXR_OK) + { + return HXR_OK; + } + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::AddRef +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientContext::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::Release +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientContext::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IHXPreferences::ReadPref +// Purpose: +// Read a Preference from the registry. +// +STDMETHODIMP +ExampleClientContext::ReadPref(const char* pref_key, IHXBuffer*& buffer) +{ + HX_RESULT hResult = HXR_OK; + char* pszCipher = NULL; + + if ((stricmp(pref_key, CLIENT_GUID_REGNAME) == 0) && + (*m_pszGUID)) + { + // Create a Buffer + buffer = new CHXBuffer(); + buffer->AddRef(); + + // Copy the encoded GUID into the buffer + buffer->Set((UCHAR*)m_pszGUID, strlen(m_pszGUID) + 1); + } + else if (m_pDefaultPrefs) + { + hResult = m_pDefaultPrefs->ReadPref(pref_key, buffer); + } + else + { + hResult = HXR_NOTIMPL; + } + + return hResult; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IHXPreferences::WritePref +// Purpose: +// Write a Preference to the registry. +// +STDMETHODIMP +ExampleClientContext::WritePref(const char* pref_key, IHXBuffer* buffer) +{ + if (m_pDefaultPrefs) + { + return m_pDefaultPrefs->WritePref(pref_key, buffer); + } + else + { + return HXR_OK; + } +} + +EHXClientState ExampleClientContext::GetState() +{ + return m_pClientStateSink->GetState(); +}; Index: helix-libs/clientapps/clutter/excontxt.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/excontxt.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,106 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ +#ifndef _EXCONTXT_H_ +#define _EXCONTXT_H_ + +#include "exerror.h" +#include "exsitsup.h" +#include "hxprefs.h" +#include "player.h" +#include "hxclsnk.h" + +struct IUnknown; +struct IHXPreferences; +class ExampleClientAdviceSink; +class ExampleClientStateAdviceSink; +class ExampleErrorMessages; +class ExampleAuthenticationManager; +class ExamplePDStatusObserver; + + +class ExampleClientContext : public IHXPreferences +{ +private: + LONG32 m_lRefCount; + LONG32 m_lClientIndex; + + ExampleClientAdviceSink* m_pClientSink; + ExampleClientStateAdviceSink* m_pClientStateSink; + ExampleErrorSink* m_pErrorSink; + ExampleAuthenticationManager* m_pAuthMgr; + + ExampleSiteSupplier* m_pSiteSupplier; + ExamplePDStatusObserver* m_pPrgDnldStatusObserver; + IHXPreferences* m_pDefaultPrefs; + char m_pszGUID[256]; /* Flawfinder: ignore */ + + +public: + + ExampleClientContext(LONG32 /*IN*/ lClientIndex); + ~ExampleClientContext(); + + void Init(IUnknown* /*IN*/ pUnknown, + IHXPreferences* /*IN*/ pPreferences, + char* /*IN*/ pszGUID, + on_buffering_cb_t on_buffering_cb = NULL, + on_pos_length_cb_t on_pos_length_cb = NULL, + on_state_change_cb_t on_state_change_cb = NULL, + on_new_frame_cb_t on_new_frame_cb = NULL, + void *context = NULL); + void Close(); + + EHXClientState GetState(); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXPreferences methods + */ + STDMETHOD(ReadPref) (THIS_ const char* pref_key, + IHXBuffer*& buffer); + STDMETHOD(WritePref) (THIS_ const char* pref_key, + IHXBuffer* buffer); +}; + +#endif Index: helix-libs/clientapps/clutter/exerror.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exerror.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,230 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include "hxtypes.h" + +#include "hxcom.h" +#include "hxcomm.h" +#include "hxerror.h" +#include "hxstrutl.h" +#include "hxcore.h" +#include "hxassert.h" +#include "hxbuffer.h" + +#ifdef __TCS__ +#include "hxresult.h" +#endif + +#if !defined(HELIX_CONFIG_MINIMIZE_SIZE) +#include "HXErrorCodeStrings.h" +#endif + +#include "exerror.h" + +#include +#include "print.h" + +#include "globals.h" +struct _stGlobals*& GetGlobal(); //in main.cpp + +#ifdef __TCS__ +#if defined(__cplusplus) +extern "C" { +#endif + +void hookRealAudio_ReportError(int err, long errVal); + +#ifdef __cplusplus +} +#endif +#endif + +ExampleErrorSink::ExampleErrorSink(IUnknown* pUnknown) + : m_lRefCount(0), + m_pPlayer(NULL) +{ + IHXClientEngine* pEngine = NULL; + pUnknown->QueryInterface(IID_IHXClientEngine, (void**)&pEngine ); + if( pEngine ) + { + IUnknown* pTmp = NULL; + pEngine->GetPlayer(0, pTmp); + m_pPlayer = (IHXPlayer*)pTmp; + } + + HX_RELEASE( pEngine ); + HX_ASSERT(m_pPlayer); +} + +ExampleErrorSink::~ExampleErrorSink() +{ + HX_RELEASE(m_pPlayer); +} + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::QueryInterface +// Purpose: +// Implement this to export the interfaces supported by your +// object. +// +STDMETHODIMP ExampleErrorSink::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXErrorSink*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXErrorSink)) + { + AddRef(); + *ppvObj = (IHXErrorSink*) this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::AddRef +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleErrorSink::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::Release +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleErrorSink::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + +/* + * IHXErrorSink methods + */ + +STDMETHODIMP +ExampleErrorSink::ErrorOccurred(const UINT8 unSeverity, + const ULONG32 ulHXCode, + const ULONG32 ulUserCode, + const char* pUserString, + const char* pMoreInfoURL + ) +{ + char HXDefine[256]; /* Flawfinder: ignore */ + + // Store the code, so we can return it from main() + GetGlobal()->g_Error = ulHXCode; + + ConvertErrorToString(ulHXCode, HXDefine, 256); + +#ifdef __TCS__ + hookRealAudio_ReportError(ulHXCode,ulUserCode); +#else + STDOUT("Report(%d, %ld, \"%s\", %ld, \"%s\", \"%s\")\n", + unSeverity, + ulHXCode, + (pUserString && *pUserString) ? pUserString : "(NULL)", + ulUserCode, + (pMoreInfoURL && *pMoreInfoURL) ? pMoreInfoURL : "(NULL)", + HXDefine); +#endif + + return HXR_OK; +} + +void +ExampleErrorSink::ConvertErrorToString(const ULONG32 ulHXCode, char* pszBuffer, UINT32 ulBufLen) +{ + IHXErrorMessages* pErrMsg = NULL; + + if( !pszBuffer) + return; + + pszBuffer[0]='\0'; + + HX_ASSERT(m_pPlayer); + if( m_pPlayer) + { + m_pPlayer->QueryInterface(IID_IHXErrorMessages, (void**)&pErrMsg); + if( pErrMsg ) + { + IHXBuffer* pMessage = pErrMsg->GetErrorText(ulHXCode); + if( pMessage ) + { + SafeStrCpy( pszBuffer, (const char*)pMessage->GetBuffer(), ulBufLen); + pMessage->Release(); + } + } + HX_RELEASE(pErrMsg); + } + + if( strlen(pszBuffer)==0 ) + { +#if !defined(HELIX_CONFIG_MINIMIZE_SIZE) + const char* pszHXCodeString = HXErrorCodeToString(ulHXCode); + if (pszHXCodeString) + { + SafeSprintf( pszBuffer, ulBufLen, "%s", pszHXCodeString); + } + else +#endif + { + HX_ASSERT(FALSE); + SafeSprintf( pszBuffer, ulBufLen, "Can't convert error code %p - make sure it's defined in common/util/HXErrorCodeStrings.c", ulHXCode ); + } + } +} + Index: helix-libs/clientapps/clutter/exerror.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exerror.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,92 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXAMPLEERRORMESSAGES_ +#define _EXAMPLEERRORMESSAGES_ + +#include "hxerror.h" + +struct IUnknown; +struct IHXErrorMessages; +struct IHXPlayer; + +class ExampleErrorSink : public IHXErrorSink +{ +public: + + ExampleErrorSink(IUnknown* pUnknown); + ~ExampleErrorSink(); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXErrorSink methods + */ + + /************************************************************************ + * Method: + * IHXErrorSink::ErrorOccurred + * Purpose: + * After you have registered your error sink with an IHXErrorSinkControl + * (either in the server or player core) this method will be called to + * report an error, event, or status message. + * + * The meaning of the arguments is exactly as described in + * hxerror.h + */ + STDMETHOD(ErrorOccurred) (THIS_ + const UINT8 unSeverity, + const ULONG32 ulHXCode, + const ULONG32 ulUserCode, + const char* pUserString, + const char* pMoreInfoURL + ); + +protected: + LONG32 m_lRefCount; + IHXPlayer* m_pPlayer; + + void ConvertErrorToString (const ULONG32 ulHXCode, char* pszBuffer, UINT32 ulBufLen); +}; +#endif /*_EXAMPLEERRORMESSAGES_*/ Index: helix-libs/clientapps/clutter/exprdnld.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exprdnld.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,468 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include "hxcom.h" +#include "hxtypes.h" +#include "hxcore.h" +#include "hxprdnld.h" +#include "exprdnld.h" +#include "print.h" + +#include "globals.h" +struct _stGlobals*& GetGlobal(); + +UINT32 GetTime(); // /In main.cpp. + +// /#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS) +/************************************************************************ + * Method: + * Constructor + */ +ExamplePDStatusObserver::ExamplePDStatusObserver(IUnknown* pUnkPlayer) + : m_lRefCount(0) + , m_pPrgDnldStatusMgr(NULL) + , m_pUnkPlayer(pUnkPlayer) + , m_pHXPlayer(NULL) + , m_bPlayerIsPausedByThis(FALSE) + , m_bFirstPDStatusMessage(TRUE) + , m_ulTotalDurReported(HX_PROGDOWNLD_UNKNOWN_DURATION) + , m_ulDurSoFar(HX_PROGDOWNLD_UNKNOWN_DURATION) + , m_ulCurStatusUpdateGranularity( + HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC) + , m_bInitialPrerollUpateGranularitySet(FALSE) + , m_bDownloadIsComplete(FALSE) +{ + if (m_pUnkPlayer) + { + m_pUnkPlayer->QueryInterface(IID_IHXPlayer, + (void**)&m_pHXPlayer); + + m_pUnkPlayer->QueryInterface(IID_IHXPDStatusMgr, + (void**)&m_pPrgDnldStatusMgr); + + if (m_pPrgDnldStatusMgr) + { + // /Add ourselves as an observer of progressive download playback: + m_pPrgDnldStatusMgr->AddObserver(this); + // /Set granularity of status reports to 10 per second until we + // know enough about the situation to go back to getting reports + // at the default interval (every 5 seconds). Do that as soon + // as we receive the first progress report: + m_ulCurStatusUpdateGranularity = 100; + } + + m_pUnkPlayer->AddRef(); + } +}; + +/************************************************************************ + * Method: + * Destructor + */ +ExamplePDStatusObserver::~ExamplePDStatusObserver() +{ + if (m_pPrgDnldStatusMgr) + { + m_pPrgDnldStatusMgr->RemoveObserver(this); + } + HX_RELEASE(m_pPrgDnldStatusMgr); + HX_RELEASE(m_pHXPlayer); + HX_RELEASE(m_pUnkPlayer); +} + +/************************************************************************ + * Method: + * IUnknown::QueryInterface + */ +STDMETHODIMP +ExamplePDStatusObserver::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXPDStatusObserver*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXPDStatusObserver)) + { + AddRef(); + *ppvObj = (IHXPDStatusObserver*)this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +/************************************************************************ + * Method: + * IUnknown::AddRef + */ +STDMETHODIMP_(ULONG32) +ExamplePDStatusObserver::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +/************************************************************************ + * Method: + * IUnknown::Release + */ +STDMETHODIMP_(ULONG32) +ExamplePDStatusObserver::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + + +/* + * IHXPDStatusObserver methods + */ + +/************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadProgress + * + * Purpose: + * Notification from IHXPDStatusMgr of download progress when + * file size changes. + * + * lTimeSurplus: + * - When negative, the absolute value of it is the estimated number + * of milliseconds of wall-clock time that need to pass while + * downloading continues before reaching the point at which playback + * can resume and play the remainder of the stream without having to + * buffer, assuming that playback is paused and remains so during + * that period. + * - When positive, it is the estimated number of milliseconds of + * wall-clock time between when the download should complete and when + * the natural content play-out duration will be reached, assuming + * playback is currently progressing and that no pause will occur. + * + * Note: ulNewDurSoFar can be HX_PROGDOWNLD_UNKNOWN_DURATION if the + * IHXMediaBytesToMediaDur was not available to, or was unable to + * convert the bytes to a duration for the IHXPDStatusMgr calling this: + */ +STDMETHODIMP +ExamplePDStatusObserver::OnDownloadProgress( + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource, + UINT32 /*IN*/ ulNewDurSoFar, + UINT32 /*IN*/ ulNewBytesSoFar, + INT32 /*IN*/ lTimeSurplus) +{ + m_ulDurSoFar = ulNewDurSoFar; + + if (m_ulCurStatusUpdateGranularity < + HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC) + { + if (m_bInitialPrerollUpateGranularitySet) + { + if (HX_PROGDOWNLD_UNKNOWN_DURATION != ulNewDurSoFar && + // /Preroll is done, so reset update interval back to default: + GetGlobal()->g_bOnBeginOccurred) + { + m_ulCurStatusUpdateGranularity = + HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC; + m_pPrgDnldStatusMgr->SetStatusUpdateGranularityMsec( + m_ulCurStatusUpdateGranularity); + } + } + else if (!GetGlobal()->g_bOnBeginOccurred) + { + if (HXR_OK == m_pPrgDnldStatusMgr->SetStatusUpdateGranularityMsec( + m_ulCurStatusUpdateGranularity)) + { + m_bInitialPrerollUpateGranularitySet = TRUE; + } + } + } + + UINT32 ulCurPlayTime = 0; + + HXBOOL bPauseWasAttempted = FALSE; + HXBOOL bPauseOccurred = FALSE; + HXBOOL bResumeWasAttempted = FALSE; + HXBOOL bResumeOccurred = FALSE; + + + if (m_pHXPlayer) + { + ulCurPlayTime = m_pHXPlayer->GetCurrentPlayTime(); + + if (GetGlobal()->g_bEnableSlowStart && + lTimeSurplus != HX_PROGDOWNLD_UNKNOWN_TIME_SURPLUS) + { + // /"slow start" is enabled so if we have run dry of data, + // pause and wait for more data: + if (!m_bPlayerIsPausedByThis) + { + if (!m_bDownloadIsComplete && lTimeSurplus<0) + { + // /Use a 1000-millisecond allowance for variation: + if (lTimeSurplus < -1000) + { + bPauseWasAttempted = TRUE; + bPauseOccurred = m_bPlayerIsPausedByThis = + (HXR_OK == m_pHXPlayer->Pause()); + } + } + } + else // /paused; see if we can resume yet: + { + if (lTimeSurplus > 0) + { + // /Use a 1000-millisecond allowance for variation: + if (lTimeSurplus > 1000) + { + bResumeWasAttempted = TRUE; + bResumeOccurred = (HXR_OK == m_pHXPlayer->Begin()); + m_bPlayerIsPausedByThis = !bResumeOccurred; + } + } + } + } + } + + if (GetGlobal()->bEnableVerboseMode && !m_bDownloadIsComplete) + { + STDOUT("\nDownload progress: (play time=%lu,", + ulCurPlayTime); + if (HX_PROGDOWNLD_UNKNOWN_TIME_SURPLUS == lTimeSurplus) + { + STDOUT(" UNKNOWN surplus|deficit)"); + } + else if (HX_PROGDOWNLD_MIN_TIME_SURPLUS == lTimeSurplus) + { + STDOUT(" deficit exceeds maximum"); + } + else if (HX_PROGDOWNLD_MAX_TIME_SURPLUS == lTimeSurplus) + { + STDOUT(" surplus exceeds maximum)"); + } + else + { + STDOUT(" surplus=%ld milliseconds)", lTimeSurplus); + } + if (HX_PROGDOWNLD_UNKNOWN_DURATION == ulNewDurSoFar) + { + STDOUT("\n\thave UNKNOWN"); + } + else + { + STDOUT("\n\thave %lu", ulNewDurSoFar); + } + + if (HX_PROGDOWNLD_UNKNOWN_DURATION != m_ulTotalDurReported) + { + STDOUT(" of %lu msec", m_ulTotalDurReported); + } + else + { + STDOUT(" of UNKNOWN msec of media"); + } + if (HX_PROGDOWNLD_UNKNOWN_FILE_SIZE != ulNewBytesSoFar) + { + STDOUT(" (%lu", ulNewBytesSoFar); + } + else + { + STDOUT(" (UNKNOWN"); + } + STDOUT(" bytes downloaded so far)\n", ulNewBytesSoFar); + + if (bPauseOccurred || bPauseWasAttempted) + { + STDOUT("# Waiting for more data: %splayback.\n " + " Should take %ld milliseconds before playback resumes.\n", + bPauseOccurred? "Pausing " : + (bPauseWasAttempted? "Failed attempting to pause " + : " "), -lTimeSurplus); + } + if (bResumeOccurred || bResumeWasAttempted) + { + STDOUT("# Data available: %splayback\n " + " Time surplus is now %ld", + bResumeOccurred? "Resuming " : + (bResumeWasAttempted? "Failed attempting to resume " + : " "), lTimeSurplus); + } + } + + m_bFirstPDStatusMessage = FALSE; + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXPDStatusObserver::OnTotalDurChanged + * Purpose: + * This is a notification if the total file duration becomes known + * or becomes better-known during download/playback + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ +STDMETHODIMP +ExamplePDStatusObserver::OnTotalDurChanged( + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource, + UINT32 ulNewTotalDur) +{ + m_ulTotalDurReported = ulNewTotalDur; + + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nOnTotalDurChanged(): to %lu milliseconds\n", ulNewTotalDur); + } + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadComplete + * + * Purpose: + * Notification that the entire file has been downloaded. + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + * + */ +STDMETHODIMP +ExamplePDStatusObserver::OnDownloadComplete( + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource) +{ + m_bDownloadIsComplete = TRUE; + + HXBOOL bResumeWasAttempted = FALSE; + HXBOOL bResumeOccurred = FALSE; + + // /In case we're paused, resume now that there is no more data to get: + if (m_pHXPlayer && m_bPlayerIsPausedByThis) + { + bResumeWasAttempted = TRUE; + bResumeOccurred = (HXR_OK == m_pHXPlayer->Begin()); + m_bPlayerIsPausedByThis = !bResumeOccurred; + } + + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nOnDownloadComplete()\n"); + if (bResumeOccurred || bResumeWasAttempted) + { + STDOUT("\n%splayback now that bytes are available for " + "uninterrupted playback\n", + bResumeOccurred? "Resuming " : + (bResumeWasAttempted? "Failed attempting to resume " + : " ")); + } + } + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXPDStatusObserver::SrcClaimsSeekSupport ref: hxprdnld.h + * Purpose: + * Passes along notification from file sys that seek support + * is or is not claimed to be available (although sometimes HTTP + * server claims this when it doesn't actually support it). + */ +STDMETHODIMP +ExamplePDStatusObserver::SrcClaimsSeekSupport(IHXStreamSource* pStreamSource, + HXBOOL bClaimsSupport) +{ + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nSrcClaimsSeekSupport(%sE)\n", bClaimsSupport?"TRU":"FALS"); + } + return HXR_OK; +} + + +/************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadPause + * Purpose: + * Notification that the file-download process has purposefully + * and temporarily halted downloading of the file + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ +STDMETHODIMP +ExamplePDStatusObserver::OnDownloadPause( + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource) +{ + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nOnDownloadPause()\n"); + } + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadResume + * Purpose: + * Notification that the file-download process has resumed + * the process of downloading the remainder of the file + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ +STDMETHODIMP +ExamplePDStatusObserver::OnDownloadResume( + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource) +{ + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nOnDownloadResume()\n"); + } + return HXR_OK; +} +// /#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS. Index: helix-libs/clientapps/clutter/exprdnld.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exprdnld.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,196 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXPRDNLD_H_ +#define _EXPRDNLD_H_ + +// /#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS) + +/**************************************************************************** + * + * Class: + * + * ExamplePDStatusObserver + * + * Purpose: + * + * Implementation for IHXPDStatusObserver which receives progressive- + * download status reports: + * + */ +class ExamplePDStatusObserver : + public IHXPDStatusObserver +{ +private: + INT32 m_lRefCount; + IHXPDStatusMgr* m_pPrgDnldStatusMgr; + IUnknown* m_pUnkPlayer; + IHXPlayer* m_pHXPlayer; + HXBOOL m_bPlayerIsPausedByThis; + HXBOOL m_bFirstPDStatusMessage; + UINT32 m_ulTotalDurReported; + UINT32 m_ulDurSoFar; + UINT32 m_ulCurStatusUpdateGranularity; + HXBOOL m_bInitialPrerollUpateGranularitySet; + HXBOOL m_bDownloadIsComplete; + + ExamplePDStatusObserver(); + ~ExamplePDStatusObserver(); + +public: + ExamplePDStatusObserver(IUnknown* pUnkPlayer); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXPDStatusObserver methods + */ + + /************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadProgress + * + * Purpose: + * Notification from IHXPDStatusMgr of download progress when + * file size changes. + * + * lTimeSurplus: + * - When negative, the absolute value of it is the estimated number + * of milliseconds of wall-clock time that need to pass while + * downloading continues before reaching the point at which playback + * can resume and play the remainder of the stream without having to + * buffer, assuming that playback is paused and remains so during + * that period. + * - When positive, it is the estimated number of milliseconds of + * wall-clock time between when the download should complete and when + * the natural content play-out duration will be reached, assuming + * playback is currently progressing and that no pause will occur. + * + * Note: ulNewDurSoFar can be HX_PROGDOWNLD_UNKNOWN_DURATION if the + * IHXMediaBytesToMediaDurConverter was not available to, or was + * unable to convert the bytes to a duration for the IHXPDStatusMgr + * calling this: + */ + STDMETHOD(OnDownloadProgress) (THIS_ + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource, + UINT32 /*IN*/ ulNewDurSoFar, + UINT32 /*IN*/ ulNewBytesSoFar, + INT32 /*IN*/ lTimeSurplus); + + /************************************************************************ + * Method: + * IHXPDStatusObserver::OnTotalDurChanged + * Purpose: + * This is a notification if the total file duration becomes known + * or becomes better-known during download/playback + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ + STDMETHOD(OnTotalDurChanged) (THIS_ + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource, + UINT32 /*IN*/ ulNewDur); + + /************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadComplete + * + * Purpose: + * Notification that the entire file has been downloaded. + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + * + */ + STDMETHOD(OnDownloadComplete) (THIS_ + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource); + + /************************************************************************ + * Method: + * IHXPDStatusObserver::SrcClaimsSeekSupport + * + * Purpose: + * Passes along notification from file sys that seek support + * is claimed to be available (although sometimes HTTP server + * claims this when it doesn't actually support it). + * + */ + STDMETHOD(SrcClaimsSeekSupport) (THIS_ + IHXStreamSource* pStreamSource, + HXBOOL /*IN*/ bSrcClaimsSeekSupport); + + /************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadPause + * Purpose: + * Notification that the file-download process has purposefully + * and temporarily halted downloading of the file + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ + STDMETHOD(OnDownloadPause) (THIS_ + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource); + + /************************************************************************ + * Method: + * IHXPDStatusObserver::OnDownloadResume + * Purpose: + * Notification that the file-download process has resumed + * the process of downloading the remainder of the file + * + * Note: pStreamSource can be NULL. This will be true when + * IHXPDStatusMgr calling this is upstream of the IHXStreamSource + * object. + */ + STDMETHOD(OnDownloadResume) (THIS_ + IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource); +}; +// /#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS. + +#endif // _EXPRDNLD_H_ + Index: helix-libs/clientapps/clutter/exroot.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exroot.cpp 2008-10-13 06:54:08.000000000 -0700 @@ -0,0 +1,672 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: unixroot.cpp,v 1.9 2007/07/06 20:54:01 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +// for shared memory +#include +#include +#include +#include + +#include "hxcom.h" +#include "hxwintyp.h" +#include "hxvsurf.h" +#include "hxslist.h" +#include "colormap.h" +#include "hxprefs.h" +#include "hxtick.h" +#include "hxthread.h" +#include "basesite.h" +#include "exroot.h" +#include "exsite.h" +#include "unixcmap.h" +#include "shmhelp.h" + +// #ifdef _DEBUG +// #include //for debug video sync rates.. +// #endif + +//Work around AIX problem. +#ifdef _AIX +# define MAX_SHARED_REGIONS ((UINT32)1) +#else +# define MAX_SHARED_REGIONS ((UINT32)9999) +#endif + +CExRootSurf::CExRootSurf(IUnknown* pContext, CHXBaseSite* pSite, on_new_frame_cb_t on_new_frame_cb, void *context ) + : CBaseRootSurface(pContext, pSite) + , m_bUseShm(FALSE) + , m_nShmId(0) + , m_pDisplay(NULL) + , m_GC(0) + , m_nScreenNumber(0) + , m_pXImage(NULL) + , m_pVisual(NULL) + , m_unDepth(0) + , m_pScreen(NULL) + , m_pYUVScratchBits(NULL) + , m_nYUVScratchPitch(0) + , m_pScratchBits(NULL) + , m_nScratchPitch(0) + , m_nBitsPerPixel(0) + , m_nCompositionSize(0) + , m_on_new_frame_cb(on_new_frame_cb) + , m_context(context) +{ +} + +HX_RESULT CExRootSurf::Init() +{ + //get window and display from main Site. + HXxWindow* pWindow = m_pSite->GetWindow(); + HX_ASSERT(pWindow); + + m_pDisplay = (Display*)pWindow->display; + m_window = (Window)pWindow->window; + + HX_ASSERT( m_pDisplay ); + HX_ASSERT( m_window ); + + // + // Now see if our X11 server supports the Shared Memory extension. + // + // ShmHelp::Init(m_pDisplay); + // m_bUseShm = ShmHelp::ShmAvailable(); + + //Create the graphics context + XGCValues values; + + XLockDisplay(m_pDisplay); + m_GC = XCreateGC(m_pDisplay, m_window, 0, &values); + + //Get X window attributes & visual + XWindowAttributes attr; + XGetWindowAttributes(m_pDisplay, m_window, &attr); + XUnlockDisplay(m_pDisplay); + m_pVisual = attr.visual; + + // get visual info & depth + int nv=0; + XVisualInfo visInfo; + memset(&visInfo, 0, sizeof(XVisualInfo)); + XLockDisplay(m_pDisplay); + visInfo.visualid = XVisualIDFromVisual(m_pVisual); + XVisualInfo* pVisualInfo = XGetVisualInfo (m_pDisplay, VisualIDMask, &visInfo, &nv); +// m_unDepth = pVisualInfo->depth; + m_unDepth = 24; + m_nScreenNumber = DefaultScreen(m_pDisplay); + m_pScreen = XScreenOfDisplay(m_pDisplay, m_nScreenNumber); + XUnlockDisplay(m_pDisplay); + m_colormap = HXGetXColormap(m_pDisplay, m_window); + + // get pixmap (blt) information for the best depth we can display + int i=0; + int nNum=0; + XLockDisplay(m_pDisplay); + XPixmapFormatValues *pixmap_formats = XListPixmapFormats(m_pDisplay, &nNum); + XUnlockDisplay(m_pDisplay); + if(pixmap_formats) + { + for (i=0 ; ired_mask; + m_bmiSave.un.dwBitMask[1] = pVisualInfo->green_mask; + m_bmiSave.un.dwBitMask[2] = pVisualInfo->blue_mask; +#else + /* Fake a RGB24 */ + m_nBitsPerPixel = 24; + m_bmiSave.bmiHeader.biBitCount = m_nBitsPerPixel; + m_bmiSave.bmiHeader.biCompression = BI_RGB; +#endif + //Set primary surface CID. + m_nCompositionSurfaceCID = GetBitmapColor(&m_bmiSave); + XFree( pVisualInfo ); + +// #ifdef _DEBUG +// //Lets find out what Hsync and Vsync rates we have for this display. +// //Ripped from xvidtune.c +// XF86VidModeModeLine mode_line; +// int scrn=0; +// int dot_clock; +// double vsync_hz, HSyncRate,HTotal, VTotal, PixelClock; +// if(XF86VidModeGetModeLine(m_pDisplay, scrn, &dot_clock, &mode_line)) +// { +// PixelClock=dot_clock; +// HTotal = mode_line.htotal; +// VTotal = mode_line.vtotal; +// HSyncRate = PixelClock*1000.0/HTotal; +// vsync_hz = HSyncRate/VTotal; +// fprintf( stderr, "This Display's Hsync rate is: %f and Vsync: %f\n", +// HSyncRate, vsync_hz ); +// } + +// #endif + + return HXR_OK; +} + +CExRootSurf::~CExRootSurf() +{ + _DestroyCompositionSurface(); + + if( m_GC ) + { + XLockDisplay(m_pDisplay); + XFreeGC( m_pDisplay, m_GC ); + XUnlockDisplay(m_pDisplay); + m_GC=0; + } + if (m_pVisual) + { + /* PJG: don't have to free visuals */ + m_pVisual = NULL; + } + + if(m_bUseShm) + { + if( m_pCompositionSurface != NULL ) + ShmHelp::DetachSharedRegion(&m_pCompositionSurface, &m_shmInfo); + } + else + { + HX_DELETE(m_pCompositionSurface); + m_nCompositionSize=0; + m_bCompositionSurfaceCreated=FALSE; + } + + //XXXgfw any more clean up for these two? + HX_VECTOR_DELETE( m_pScratchBits ); + HX_VECTOR_DELETE( m_pYUVScratchBits ); + +} + +HX_RESULT CExRootSurf::_ResizeVideoBuffer( INT32 nSize) +{ + HX_RESULT retVal=HXR_OK; + + if(nSize <= m_nCompositionSize) + return retVal; + + if(m_bUseShm) + { + if( m_pCompositionSurface != NULL ) + retVal = ShmHelp::DetachSharedRegion(&m_pCompositionSurface, &m_shmInfo); + if( retVal==HXR_OK ) + { + retVal = ShmHelp::CreateSharedRegion( nSize, + &m_pCompositionSurface, + &m_nShmId, + &m_shmInfo + ); + + } + if( retVal != HXR_OK ) + { + m_bCompositionSurfaceCreated = FALSE; + m_nCompositionSize = 0; + m_bUseShm = FALSE; + } + else + { + //It all worked + m_nCompositionSize = nSize; + m_bCompositionSurfaceCreated = TRUE; + return retVal; + } + + } + + //We need to fall through here so that if the shared memory stuff + //above fails we can create it the old fashioned way. + if(m_pCompositionSurface == NULL) + { + m_pCompositionSurface = (UCHAR*) malloc(nSize); + } + else + { + m_pCompositionSurface = (UCHAR*) realloc(m_pCompositionSurface, nSize); + } + if( m_pCompositionSurface ) + { + m_nCompositionSize = nSize; + } + else + { + HX_ASSERT("We can't alloc the composition surface." == NULL ); + m_nCompositionSize = 0; + } + + return retVal; +} + +HX_RESULT CExRootSurf::_DebugBlt( UCHAR* pImageData, HXBitmapInfoHeader* pBitmapInfo, + HXxRect& rDestRect, HXxRect& rSrcRect) +{ + HX_ASSERT( m_window ); + HX_ASSERT( m_pDisplay ); + HX_ASSERT( m_GC ); + XLockDisplay(m_pDisplay); + XSetForeground( m_pDisplay, m_GC, WhitePixel(m_pDisplay, 0 )); + XSetBackground( m_pDisplay, m_GC, BlackPixel(m_pDisplay, 0 )); + XSetLineAttributes(m_pDisplay, m_GC, 5, LineSolid, CapRound, JoinRound ); + XSetForeground( m_pDisplay, m_GC, WhitePixel(m_pDisplay, 0) ); + XFillRectangle( m_pDisplay, m_window, m_GC, + rDestRect.left, rDestRect.top, + rDestRect.right-rDestRect.left, + rDestRect.bottom-rDestRect.top + ); + XDrawRectangle( m_pDisplay, m_window, m_GC, + rDestRect.left, rDestRect.top, + rDestRect.right-rDestRect.left, + rDestRect.bottom-rDestRect.top + ); + XUnlockDisplay(m_pDisplay); + return HXR_OK; +} + +void CExRootSurf::_GetYUVScratchWidthHeight(UINT32* pWidth, UINT32* pHeight) +{ + *pWidth = m_bmiYUVScratch.bmiHeader.biWidth; + *pHeight = m_bmiYUVScratch.bmiHeader.biHeight; +} + +XImage* CExRootSurf::_GetCompositionSurfaceDrawable() +{ + return m_pXImage; +} + + + +//Not used except for XING..... +void CExRootSurf::_CreateYUVScratchSurface(UINT32 width, UINT32 height) +{ + //Remove old bits.... + HX_DELETE(m_pYUVScratchBits); + + //Clear BitmapInfo struct.... + memset(&m_bmiYUVScratch, 0, sizeof(HXBitmapInfo)); + int nResult = MakeBitmap( &m_bmiYUVScratch, + sizeof(m_bmiYUVScratch), + CID_YUY2, + width, + height, + NULL, + 0); + if( nResult ) + { + m_pYUVScratchBits = new UCHAR[m_bmiYUVScratch.bmiHeader.biSizeImage]; + m_nYUVScratchPitch = GetBitmapPitch(&m_bmiYUVScratch); + } +} + + +void CExRootSurf::_GetYUVScratchSurfacePointer(UCHAR** pYUVBits, INT32* YUVPitch) +{ + *pYUVBits = m_pYUVScratchBits; + *YUVPitch = m_nYUVScratchPitch; +} + +HX_RESULT CExRootSurf::CreateScratchSurface( int nCompositionSurfaceCID, HXxSize* pSize) +{ + //Remove old bits.... + HX_DELETE(m_pScratchBits); + + //Clear BitmapInfo struct.... + memset(&m_bmiScratch, 0, sizeof(HXBitmapInfo)); + int nResult = MakeBitmap( &m_bmiScratch, + sizeof(m_bmiScratch), + nCompositionSurfaceCID, + pSize->cx, + pSize->cy, + NULL, + 0); + if( nResult ) + { + m_pScratchBits = new UCHAR[m_bmiScratch.bmiHeader.biSizeImage]; + m_nScratchPitch = GetBitmapPitch(&m_bmiScratch); + } + + return nResult? HXR_OK : HXR_FAIL; +} + +HX_RESULT CExRootSurf::ScratchLock(UCHAR** pBits, INT32* pPitch) +{ + *pBits = m_pScratchBits; + *pPitch = m_nScratchPitch; + return HXR_OK; +} + +HX_RESULT CExRootSurf::ScratchUnlock(UCHAR* pBits) +{ + return HXR_OK; +} + +HX_RESULT CExRootSurf::_MinimalUnlock(HXxWindow* pWindow) +{ +// Window win = m_window; +// HX_ASSERT(win); +// HXxSize hxxSize; +// m_pSite->GetSize(hxxSize); + +// if (m_bUseShm) +// { +// XShmPutImage(m_pDisplay, +// win, +// m_GC, +// m_pXImage, +// 0, +// 0, +// 0, +// 0, +// hxxSize.cx, +// hxxSize.cy, +// False +// ); +// } +// else +// { +// XPutImage(m_pDisplay, +// win, +// m_GC, +// m_pXImage, +// 0, +// 0, +// 0, +// 0, +// hxxSize.cx, +// hxxSize.cy +// ); +// } + return HXR_OK; +} + +HX_RESULT CExRootSurf::_LockComposition(UCHAR** pBits, INT32* pPitch) +{ + HX_RESULT retVal = HXR_OK; + if( !m_bCompositionSurfaceCreated || m_pCompositionSurface==NULL ) + { + retVal = _CreateCompositionSurface(); + } + HX_ASSERT( m_pCompositionSurface ); + *pBits = m_pCompositionSurface; + *pPitch = m_nCompositionPitch; + return HXR_OK; +} + + +void CExRootSurf::_BltFromScratchToComposition( HXxRect& rDestRect, HXxRect& rSrcRect) +{ + HX_ASSERT( "Not implemented on unix yet...."==NULL ); +} + +HX_RESULT CExRootSurf::_CreateCompositionSurface() +{ + HX_RESULT retVal = HXR_FAIL; + + if(m_bCompositionSurfaceCreated) + { + return HXR_OK; + } + + HX_ASSERT( !m_bCompositionSurfaceCreated ); + HX_ASSERT( m_pSite ); + + //Create a BMI to describe the composition surface + HXxSize hxxSize; + m_pSite->GetSize(hxxSize); + memcpy(&m_compositionSize, &hxxSize, sizeof(HXxSize)); /* Flawfinder: ignore */ + + // find out how big we want to allocate. + if (m_pSite->IsFullScreen()) + { + UINT16 unDummy=0; + UINT16 unHorzRes=0; + UINT16 unVertRes=0; + m_pSite->_GetDeviceCaps(NULL, unDummy, unHorzRes, unVertRes ); + m_allocatedCompositionSize.cx = unHorzRes; + m_allocatedCompositionSize.cy = unVertRes; + } + else + { + // we use root surface for BASIC_BLT and it assumes the offset(position) + // of the root site it cooresponding to is (0, 0). + // + // this is not true for "windowless" mode where the root site can be given + // an offset, as a result, we fail to blt the video. + // + // to fix this, we'll take the m_positionOrg into consideration when + // creating the composition surface, this may not be optimal but good enough + // for now. + // + // similar logic is also added for other platforms, we need to move this + // common code to the base class when we have chance to clean it up + if (m_compositionSize.cx && m_compositionSize.cy) + { + m_compositionSize.cx += m_pSite->m_positionOrig.x; + m_compositionSize.cy += m_pSite->m_positionOrig.y; + } + + m_allocatedCompositionSize.cx = m_compositionSize.cx; + m_allocatedCompositionSize.cy = m_compositionSize.cy; + } + + //XXXgfw uhhhh, OK. + if( m_compositionSize.cx > m_allocatedCompositionSize.cx || + m_compositionSize.cy > m_allocatedCompositionSize.cy ) + { + m_allocatedCompositionSize.cx = m_compositionSize.cx; + m_allocatedCompositionSize.cy = m_compositionSize.cy; + } + + //Make the bitmap header struct. + m_bmiComposition.bmiHeader.biBitCount = m_bmiSave.bmiHeader.biBitCount; + m_bmiComposition.bmiHeader.biCompression = m_bmiSave.bmiHeader.biCompression; + m_bmiComposition.un.dwBitMask[0] = m_bmiSave.un.dwBitMask[0]; + m_bmiComposition.un.dwBitMask[1] = m_bmiSave.un.dwBitMask[1]; + m_bmiComposition.un.dwBitMask[2] = m_bmiSave.un.dwBitMask[2]; + int nResult = MakeBitmap( &m_bmiComposition, + sizeof(m_bmiComposition), + m_nCompositionSurfaceCID, + m_allocatedCompositionSize.cx, + m_allocatedCompositionSize.cy, + NULL, + 0 + ); + m_bmiComposition.bmiHeader.biBitCount = m_bmiSave.bmiHeader.biBitCount; + m_bmiComposition.bmiHeader.biCompression = m_bmiSave.bmiHeader.biCompression; + m_bmiComposition.un.dwBitMask[0] = m_bmiSave.un.dwBitMask[0]; + m_bmiComposition.un.dwBitMask[1] = m_bmiSave.un.dwBitMask[1]; + m_bmiComposition.un.dwBitMask[2] = m_bmiSave.un.dwBitMask[2]; + + //Now create the bits.... + _ResizeVideoBuffer( m_bmiComposition.bmiHeader.biSizeImage ); + m_nCompositionPitch = GetBitmapPitch( &m_bmiComposition ); + + if( m_pXImage ) + { + XFree( m_pXImage ); + } + + if( m_bUseShm ) + { + XLockDisplay(m_pDisplay); + m_pXImage = XShmCreateImage( m_pDisplay, + m_pVisual, + m_unDepth, + ZPixmap, + (char*)m_pCompositionSurface, + &m_shmInfo, + m_allocatedCompositionSize.cx, + m_allocatedCompositionSize.cy + ); + XUnlockDisplay(m_pDisplay); + } + else + { + XLockDisplay(m_pDisplay); + m_pXImage = XCreateImage( m_pDisplay, + m_pVisual, + m_unDepth, + ZPixmap, + 0, + (char*)m_pCompositionSurface, + m_allocatedCompositionSize.cx, + m_allocatedCompositionSize.cy, + 32, + 0); + XUnlockDisplay(m_pDisplay); + } + + if( m_pXImage ) + { + m_bCompositionSurfaceCreated = TRUE; +#ifdef _BIG_ENDIAN + m_pXImage->byte_order = MSBFirst; +#else + m_pXImage->byte_order = LSBFirst; +#endif + retVal = HXR_OK; + } + return retVal; +} + +void CExRootSurf::_MinimalBlt(HXxRect& destRect) +{ + if (m_on_new_frame_cb) + { + PlayerImgInfo Info; + Info.Rect.left = destRect.left; + Info.Rect.right = destRect.right; + Info.Rect.top = destRect.top; + Info.Rect.bottom = destRect.bottom; + Info.cx = m_allocatedCompositionSize.cx; + Info.cy = m_allocatedCompositionSize.cy; + m_on_new_frame_cb(m_pCompositionSurface, + m_bmiComposition.bmiHeader.biSizeImage, + &Info, + m_context); + } +} + +HX_RESULT CExRootSurf::_DestroyCompositionSurface() +{ + HX_RESULT retVal = HXR_OK; + if( m_bCompositionSurfaceCreated ) + { + if( m_pXImage ) + { + XFree(m_pXImage); + m_pXImage = NULL; + } + m_bCompositionSurfaceCreated = FALSE; + } + + return retVal; +} + + + +HX_RESULT CExRootSurf::BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo) +{ +#ifdef _DEBUG + fprintf(stderr, "CExRootSurf::BeginOptimizedBlt Needs to be written\n" ); +#endif + return HXR_NOTIMPL; +} + +HX_RESULT CExRootSurf::OptimizedBlt( UCHAR* pImageBits, + HXxRect& rDestRect, + HXxRect& rSrcRect) +{ +#ifdef _DEBUG + fprintf(stderr, "CExRootSurf::OptimizedBlt Needs to be written\n" ); +#endif + return HXR_NOTIMPL; +} + +HX_RESULT CExRootSurf::EndOptimizedBlt(void) +{ +#ifdef _DEBUG + fprintf(stderr, "CExRootSurf::EndOptimizedBlt Needs to be written\n" ); +#endif + return HXR_NOTIMPL; +} + +HX_RESULT CExRootSurf::GetOptimizedFormat(HX_COMPRESSION_TYPE& ulType) +{ +#ifdef _DEBUG + fprintf(stderr, "CExRootSurf::GetOptimizedFormat Needs to be written\n" ); +#endif + return HXR_NOTIMPL; +} + +HX_RESULT CExRootSurf::GetPreferredFormat(HX_COMPRESSION_TYPE& ulType) +{ +#ifdef _DEBUG + fprintf(stderr, "CExRootSurf::GetPreferredFormat Needs to be written\n" ); +#endif + return HXR_NOTIMPL; +} + +GC CExRootSurf::GetGC() +{ + return m_GC; +} Index: helix-libs/clientapps/clutter/exroot.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exroot.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,155 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: unixroot.h,v 1.8 2007/07/06 20:54:05 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _UNIXROOT_H +#define _UNIXROOT_H + +#include "baseroot.h" +#if defined(USE_XWINDOWS) +#include +#include +#include +#include +#include +#include +#endif + +#include "player.h" + +class CExRootSurf : public CBaseRootSurface +{ +public: + CExRootSurf(IUnknown* pContext, CHXBaseSite* pSite, on_new_frame_cb_t on_new_frame_cb = NULL, void *context = NULL); + + //Helpers.... + HX_RESULT Init(); + GC GetGC(); + + //public inherited stuff + virtual HX_RESULT CreateScratchSurface(int nCompositionSurfaceCID, + HXxSize* pSize); + virtual HX_RESULT ScratchLock(UCHAR** pBits, INT32* pPitch); + virtual HX_RESULT ScratchUnlock(UCHAR* pBits); + + virtual HX_RESULT BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo); + virtual HX_RESULT OptimizedBlt( UCHAR* pImageBits, + HXxRect& rDestRect, + HXxRect& rSrcRect); + virtual HX_RESULT EndOptimizedBlt(void); + virtual HX_RESULT GetOptimizedFormat(HX_COMPRESSION_TYPE& ulType); + virtual HX_RESULT GetPreferredFormat(HX_COMPRESSION_TYPE& ulType); + + XImage* _GetCompositionSurfaceDrawable(); + + //Shared Memory helper func for the basesurf to use. +// HX_RESULT _DetachSharedRegion(); +// HX_RESULT _CreateSharedRegion(INT32 nSize); + +protected: + + //Smartly handle resizing of shm buffer. + HX_RESULT _ResizeVideoBuffer(INT32 nSize); + + //Inherited from CBaseRootSurface.... + virtual void _BltFromScratchToComposition(HXxRect& rDestRect, + HXxRect& rSrcRect); + virtual HX_RESULT _DebugBlt( UCHAR* pImageData, + HXBitmapInfoHeader* pBitmapInfo, + HXxRect& rDestRect, + HXxRect& rSrcRect); + virtual void _GetYUVScratchWidthHeight(UINT32* pWidth, UINT32* pHeight); + virtual void _CreateYUVScratchSurface(UINT32 width, UINT32 height); + virtual void _GetYUVScratchSurfacePointer(UCHAR** pYUVBits, INT32* YUVPitch); + virtual HX_RESULT _MinimalUnlock(HXxWindow* pWindow); + virtual HX_RESULT _LockComposition(UCHAR** pBits, INT32* pPitch); + virtual HX_RESULT _CreateCompositionSurface(); + virtual HX_RESULT _DestroyCompositionSurface(); + virtual void _MinimalBlt(HXxRect& dest); + + +private: + + virtual ~CExRootSurf(); + + //Protect unintentional copy and default ctors. + CExRootSurf(); + CExRootSurf( const CExRootSurf& ); + CExRootSurf& operator=( const CExRootSurf& it ); + + //Shared memory members. + HXBOOL m_bUseShm; + XShmSegmentInfo m_shmInfo; + int m_nShmId; + + //General display and GC stuff. + Display* m_pDisplay; + GC m_GC; + int m_nScreenNumber; + XImage* m_pXImage; + Window m_window; + Visual* m_pVisual; + unsigned int m_unDepth; + Screen* m_pScreen; + Colormap m_colormap; + int m_nBitsPerPixel; + + //Bitmap stuff. + UCHAR* m_pYUVScratchBits; + HXBitmapInfo m_bmiYUVScratch; + int m_nYUVScratchPitch; + UCHAR* m_pScratchBits; + HXBitmapInfo m_bmiScratch; + int m_nScratchPitch; + HXBitmapInfo m_bmiSave; + ULONG32 m_nCompositionSize; + on_new_frame_cb_t m_on_new_frame_cb; + void * m_context; +}; + +#endif Index: helix-libs/clientapps/clutter/exsite.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exsite.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,2915 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: unixsite.cpp,v 1.18.2.6 2008/06/05 14:24:30 lovish Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * Phil Dibowitz + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _UNIX +#error This is the UNIX platform specific implementation. +#endif + +// +// System includes... +// +#include +#include "hlxclib/string.h" +#if defined(USE_XWINDOWS) +#include +#include +#include +#include +#include +#include +#include +#include +#endif + + +// +// RMA includes... +// +#include "hxcom.h" +#include "hxcore.h" +#include "hxevent.h" +#include "hxwintyp.h" +#include "hxwin.h" +#include "hxsite2.h" +#include "hxtypes.h" +#include "exsite.h" +#include "unixcmap.h" +#include "visuals.h" +#include "region.h" +#include "basesurf.h" +#include "exroot.h" +#include "hxthread.h" +#include "hxtick.h" +#include "sitetext.h" + +#include "unixsurf.h" + +#include "hxprefs.h" + +// +// Global & Static global/member data.... +// +Display *CHXExSite::zm_display = NULL; +static CHXMapPtrToPtr z_mapSiteToWindow; + +// +// Scroll bar support +// +#define SCROLL_BAR_WIDTH 13 //Width of scroll bar. +//#define _ARROWS_SIDE_BY_SIDE 1 //Regular or side by side arrows? + + + + +// +// CHXExSite only Methods... +// +CHXExSite::CHXExSite( IUnknown* pContext, IUnknown* pUnkOuter, INT32 lInitialZorder, on_new_frame_cb_t on_new_frame_cb, void *context) + : CHXBaseSite( pContext, pUnkOuter, lInitialZorder ) + , m_pUnixEventHandler(NULL) + , m_ScrollHorizButtonL(0) + , m_ScrollHorizButtonR(0) + , m_ScrollVertButtonT(0) + , m_ScrollVertButtonB(0) + , m_winFullScreenWindow(0) + , m_winOldParent(0) + , m_bScrollingInProgress(FALSE) + , m_nScrollDir(0) + , m_bLastPointInSite(FALSE) + , m_bDamaged(FALSE) + , m_bIgnoreFocusOutInFS(FALSE) + , m_bReparent(FALSE) + , m_on_new_frame_cb(on_new_frame_cb) + , m_context(context) +#if defined(HELIX_CONFIG_MOBLIN) + , m_pAttachWindowCallback(NULL) + , m_pForceRedrawCallback(NULL) +#endif +{ + m_ptScrollVertPosT.x = m_ptScrollVertPosT.y = 0; + m_ptScrollVertPosB.x = m_ptScrollVertPosB.y = 0; + m_ptScrollHorizPosR.x = m_ptScrollHorizPosR.y = 0; + m_ptScrollHorizPosL.x = m_ptScrollHorizPosL.y = 0; + m_ptFullScreenOffset.x = m_ptFullScreenOffset.y = 0; + memset( &m_PreFullScreenSize, 0, sizeof( m_PreFullScreenSize ) ); + + HX_ASSERT( m_pContext ); + + /* Replace m_pVideoSurface with my own */ +/* HX_RELEASE(m_pVideoSurface); + m_pVideoSurface = new CUnixSurf(m_pContext, this); + HX_ASSERT( m_pVideoSurface ); + m_pVideoSurface->InitSurface(m_pContext); + m_pVideoSurface->AddRef(); +*/ + IHXPreferences* pPreferences = NULL; + if( m_pContext && HXR_OK == m_pContext->QueryInterface( IID_IHXPreferences, (void **) &pPreferences)) + { + IHXBuffer *pBuffer = NULL; + pPreferences->ReadPref("IgnoreFocusOutInFS", pBuffer); + if(pBuffer) + { + m_bIgnoreFocusOutInFS = (::atoi((const char*)pBuffer->GetBuffer()) == 1); + HX_RELEASE(pBuffer); + } + } +} + +CHXExSite::~CHXExSite() +{ +#if defined(HELIX_CONFIG_MOBLIN) + RemovePendingCallback(m_pAttachWindowCallback); + HX_RELEASE(m_pAttachWindowCallback); + + RemovePendingCallback(m_pForceRedrawCallback); + HX_RELEASE(m_pForceRedrawCallback); +#endif + void* pDummy; + if (z_mapSiteToWindow.Lookup((void*)this, pDummy)) + { + z_mapSiteToWindow.RemoveKey((void*)this); + } + + if( m_pUnixEventHandler ) + { + m_pUnixEventHandler->CancelCallback(); + HX_RELEASE(m_pUnixEventHandler); + } +} + +HX_RESULT CHXExSite::_OpenXDisplay(char* pszDisplayString) +{ + HX_RESULT retVal = HXR_OK; + + //Is the connection open already? + if( NULL==zm_display ) + { + zm_display = XOpenDisplay(pszDisplayString); + + //If you can't open the display your done. + if(NULL == zm_display ) + { + HX_ASSERT("Can't open X Display..."==NULL); + retVal = HXR_FAIL; + } + else + { + HX_ASSERT(m_pScheduler); + if( m_pScheduler ) + { + //UnixEventHandler scheduls itself for init callback + //in the ctor. + m_pUnixEventHandler = new UnixEventHandler(this); + m_pUnixEventHandler->AddRef(); + } + } + } + return retVal; +} + +Window CHXExSite::CreateXWindow( Window win ) +{ + Window parentWindow; + HXxWindow* pWindow = NULL; + //If parentWin is NULL then we belong to the root window. + if( win ) + { + parentWindow = win; + } + else + { + HX_ASSERT(zm_display); + XLockDisplay(zm_display); + parentWindow = RootWindow(zm_display, DefaultScreen(zm_display)); + XUnlockDisplay(zm_display); + } + + //Find the best visual to use on this display. + Visual* visual = GetBestVisual(zm_display); + + //Get the visual info. + int nNotUsed=0; + XVisualInfo stVisInfo; + + memset(&stVisInfo, 0, sizeof(XVisualInfo)); + stVisInfo.visualid = XVisualIDFromVisual(visual); + XLockDisplay(zm_display); + XVisualInfo* pVisual = XGetVisualInfo( zm_display, + VisualIDMask, + &stVisInfo, + &nNotUsed ); + XUnlockDisplay(zm_display); + + // Set up attributes of the window. + int attrMask = CWBackPixel | CWBorderPixel; + XSetWindowAttributes attr; + + memset(&attr, 0, sizeof(XSetWindowAttributes)); + XLockDisplay(zm_display); + attr.background_pixel = BlackPixel(zm_display, DefaultScreen(zm_display)); + attr.border_pixel = BlackPixel(zm_display, DefaultScreen(zm_display)); + XUnlockDisplay(zm_display); + + //See if the default visaul of hte screen is the same one we Want + //to use. If not, create a new one and install it. + Colormap cmap; + XLockDisplay(zm_display); + Visual* defVisual = DefaultVisual(zm_display, DefaultScreen(zm_display)); + XUnlockDisplay(zm_display); + if( defVisual->visualid != stVisInfo.visualid ) + { + //XXXgfw Are we leaking this colormap???? + XLockDisplay(zm_display); + cmap = XCreateColormap(zm_display, parentWindow, visual, AllocNone); + XUnlockDisplay(zm_display); + attr.colormap = cmap; + attrMask |= CWColormap; + } + + // Set the size/position of the window before creating. + XSizeHints size_hints; + + size_hints.flags = PPosition | PSize; + size_hints.x = m_position.x; + size_hints.y = m_position.y; + size_hints.width = 1; + size_hints.height = 1; + + //Create it. + XLockDisplay(zm_display); + Window window = XCreateWindow(zm_display, + parentWindow, + size_hints.x, + size_hints.y, + size_hints.width, + size_hints.height, + 0, + pVisual->depth, + InputOutput, + visual, + attrMask, + &attr); + XUnlockDisplay(zm_display); + XFree(pVisual); + + //Tell the WM about this window. +#if 0 + XSetStandardProperties( zm_display, + window, + "CHXExSite", + "CHXExSite", + None, + NULL, 0, + &size_hints + ); +#endif + + //Select all input events on the window since the other platforms + //we work with have no concept of event masks + XLockDisplay(zm_display); +#if 0 + int result = XSelectInput( zm_display, window, + ButtonPressMask | ButtonReleaseMask | KeyPressMask | + KeyReleaseMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask | ButtonMotionMask | KeymapStateMask | + ExposureMask | StructureNotifyMask | FocusChangeMask + ); +#else + int result = XSelectInput( zm_display, window, 0 ); + + +#endif + XUnlockDisplay(zm_display); + if( BadWindow == result ) + { +#ifdef _DEBUG + fprintf( stderr, "Can select events.\n" ); +#endif + } + + //Map the window. + XLockDisplay(zm_display); + /* XMapWindow(zm_display, window); */ + + //Flush event queue. + XFlush(zm_display); + XUnlockDisplay(zm_display); + + + return window; +} + +void CHXExSite::_MapHorzScroll() +{ +#if 0 + if( GetWindow() && GetWindow()->display && m_ScrollHorizButtonL) + { + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XMapWindow( pDis, m_ScrollHorizButtonL ); + XMapWindow( pDis, m_ScrollHorizButtonR ); + XUnlockDisplay(pDis); + } + _DrawArrows(); +#endif +} + +void CHXExSite::_MapVertScroll() +{ +#if 0 + if( GetWindow() && GetWindow()->display && m_ScrollVertButtonT) + { + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XMapWindow( pDis, m_ScrollVertButtonT ); + XMapWindow( pDis, m_ScrollVertButtonB ); + XUnlockDisplay(pDis); + } + _DrawArrows(); +#endif +} + +void CHXExSite::_MapScrollButtons() +{ +#if 0 + _MapHorzScroll(); + _MapVertScroll(); +#endif +} + +void CHXExSite::_UnmapHorzScroll() +{ +#if 0 + HX_ASSERT( GetWindow() ); + if( m_ScrollHorizButtonL && GetWindow()->display ) + { + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XUnmapWindow( pDis, m_ScrollHorizButtonL ); + XUnmapWindow( pDis, m_ScrollHorizButtonR ); + XUnlockDisplay(pDis); + } +#endif +} +void CHXExSite::_UnmapVertScroll() +{ +#if 0 + HX_ASSERT( GetWindow() ); + if( m_ScrollVertButtonT && GetWindow()->display ) + { + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XUnmapWindow( pDis, m_ScrollVertButtonT ); + XUnmapWindow( pDis, m_ScrollVertButtonB ); + XUnlockDisplay(pDis); + } +#endif +} + +void CHXExSite::_UnmapScrollButtons() +{ +#if 0 + if( GetWindow() ) + { + _UnmapVertScroll(); + _UnmapHorzScroll(); + } +#endif +} + +void CHXExSite::_DestroyScrollButtons() +{ + HXxWindow* pWin = GetWindow(); + Display* pDis = (Display*)(pWin?pWin->display:NULL); + + if( m_ScrollHorizButtonL && pDis ) + { + XLockDisplay(pDis); + XDestroyWindow( pDis, m_ScrollHorizButtonL ); + m_ScrollHorizButtonL = 0; + XDestroyWindow( pDis, m_ScrollHorizButtonR ); + XUnlockDisplay(pDis); + m_ScrollHorizButtonR = 0; + } + + if( m_ScrollVertButtonT && pDis) + { + XLockDisplay(pDis); + XDestroyWindow( pDis, m_ScrollVertButtonT ); + m_ScrollVertButtonT = 0; + XDestroyWindow( pDis, m_ScrollVertButtonB ); + XUnlockDisplay(pDis); + m_ScrollVertButtonB = 0; + } + m_ptScrollVertPosT.x = m_ptScrollVertPosT.y = 0; + m_ptScrollVertPosB.x = m_ptScrollVertPosB.y = 0; + m_ptScrollHorizPosR.x = m_ptScrollHorizPosR.y = 0; + m_ptScrollHorizPosL.x = m_ptScrollHorizPosL.y = 0; +} + +void CHXExSite::_DrawArrows() +{ +#if 0 //Paul Debug + //only do the work if our site is visible. + if( !IsSiteVisible() ) + return; + + //Draw an arrow on this window. + XPoint points[4]; + int offset = SCROLL_BAR_WIDTH/10; + GC tmpGC; + XGCValues values; + Display* dis = (Display*)GetWindow()->display; + + if( m_ScrollVertButtonB ) + { + XLockDisplay(dis); + tmpGC = XCreateGC( dis, m_ScrollVertButtonB, 0, &values ); + XUnlockDisplay(dis); + } + else if( m_ScrollHorizButtonL ) + { + XLockDisplay(dis); + tmpGC = XCreateGC( dis, m_ScrollHorizButtonL, 0, &values ); + XUnlockDisplay(dis); + } + else + { + //We don't have any scroll bars to draw.... + return; + } + + + XLockDisplay(dis); + XSetForeground( dis, tmpGC, WhitePixel(dis, 0 )); + XSetBackground( dis, tmpGC, BlackPixel(dis, 0 )); + XUnlockDisplay(dis); + Colormap cmap = HXGetXColormap((Display*)GetWindow()->display, + (Window)GetWindow()->window); + XColor color; + + memset(&color, 0, sizeof(XColor)); + XLockDisplay(dis); + XParseColor(dis, cmap, "blue", &color); + XUnlockDisplay(dis); + HXFindBestXColor(dis, cmap, &color); + XLockDisplay(dis); + XSetForeground( dis, tmpGC, color.pixel); + XSetLineAttributes(dis, tmpGC, 1, LineSolid, CapRound, JoinRound ); + XUnlockDisplay(dis); + + + //Draw up Vertical arrow. + if( m_ScrollVertButtonT ) + { + points[0].x = offset; + points[0].y = SCROLL_BAR_WIDTH-offset; + points[1].x = SCROLL_BAR_WIDTH/2; + points[1].y = offset; + points[2].x = SCROLL_BAR_WIDTH-offset; + points[2].y = SCROLL_BAR_WIDTH-offset; + points[3].x = points[0].x; + points[3].y = points[0].y; + XLockDisplay(dis); + XFillPolygon( dis, m_ScrollVertButtonT, tmpGC, points, 4, Convex, CoordModeOrigin); + XUnlockDisplay(dis); + } + + //Draw down Vertical arrow. + if( m_ScrollVertButtonB ) + { + points[0].x = offset; + points[0].y = offset; + points[1].x = SCROLL_BAR_WIDTH-offset; + points[1].y = offset; + points[2].x = SCROLL_BAR_WIDTH/2; + points[2].y = SCROLL_BAR_WIDTH-offset; + points[3].x = points[0].x; + points[3].y = points[0].y; + XLockDisplay(dis); + XFillPolygon( dis, m_ScrollVertButtonB, tmpGC, points, 4, Convex, CoordModeOrigin); + XUnlockDisplay(dis); + } + + //Draw Left Horizontal arrow. + if( m_ScrollHorizButtonL ) + { + points[0].x = SCROLL_BAR_WIDTH-offset; + points[0].y = offset; + points[1].x = SCROLL_BAR_WIDTH-offset; + points[1].y = SCROLL_BAR_WIDTH-offset; + points[2].x = offset; + points[2].y = SCROLL_BAR_WIDTH/2; + points[3].x = points[0].x; + points[3].y = points[0].y; + XLockDisplay(dis); + XFillPolygon( dis, m_ScrollHorizButtonL, tmpGC, points, 4, Convex, CoordModeOrigin); + XUnlockDisplay(dis); + } + + //Draw Right Horizontal arrow. + if( m_ScrollHorizButtonR ) + { + points[0].x = offset; + points[0].y = SCROLL_BAR_WIDTH-offset; + points[1].x = offset; + points[1].y = offset; + points[2].x = SCROLL_BAR_WIDTH-offset; + points[2].y = SCROLL_BAR_WIDTH/2; + points[3].x = points[0].x; + points[3].y = points[0].y; + XLockDisplay(dis); + XFillPolygon( dis, m_ScrollHorizButtonR, tmpGC, points, 4, Convex, CoordModeOrigin); + XUnlockDisplay(dis); + } + + //Free the GC and go. + XLockDisplay(dis); + XFreeGC( dis, tmpGC ); + XUnlockDisplay(dis); +#endif +} + +HXBOOL CHXExSite::_InButton( HXxPoint& pt, int x, int y ) +{ + HXBOOL retVal =FALSE; + if( x>= pt.x && x< pt.x+SCROLL_BAR_WIDTH && y>=pt.y && yGetWindow(); + } + if(pParentWindow) + { + GetParentSite()->GetSize(mySize); + } + + HX_ASSERT( pParentWindow ); + HX_ASSERT( pParentWindow->window != 0 ); + + if( m_ScrollVertButtonB ) + { + // if the other bar already exists, don't overlap it! + mySize.cx -= SCROLL_BAR_WIDTH; + } + + m_ptScrollHorizPosL.x = m_topleft.x; + m_ptScrollHorizPosL.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH; + +#ifndef _ARROWS_SIDE_BY_SIDE + m_ptScrollHorizPosR.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH; +#else + m_ptScrollHorizPosR.x = m_topleft.x+SCROLL_BAR_WIDTH; +#endif + m_ptScrollHorizPosR.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH; + + Display* dis = (Display*)GetWindow()->display; + XLockDisplay(dis); + Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) ); + XUnlockDisplay(dis); + Pixel greyPixel = blackPixel; + + Colormap cmap = HXGetXColormap(dis, (Window)GetWindow()->window); + XColor color; + + XLockDisplay(dis); + XParseColor(dis, cmap, "gray", &color); + XUnlockDisplay(dis); + HXFindBestXColor(dis, cmap, &color); + greyPixel = color.pixel; + + XLockDisplay(dis); + m_ScrollHorizButtonL = XCreateSimpleWindow( dis, + (Window)pParentWindow->window, + m_ptScrollHorizPosL.x, m_ptScrollHorizPosL.y, + SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH, + 1, + blackPixel, + greyPixel + ); + m_ScrollHorizButtonR = XCreateSimpleWindow( dis, + (Window)pParentWindow->window, + m_ptScrollHorizPosR.x, m_ptScrollHorizPosR.y, + SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH, + 1, + blackPixel, + greyPixel + ); + XUnlockDisplay(dis); + HX_ASSERT( m_ScrollHorizButtonR && m_ScrollHorizButtonL ); + +} + +void CHXExSite::_CreateVertScrollBar() +{ + HX_ASSERT( m_ScrollVertButtonB == 0 ); + HX_ASSERT( m_ScrollVertButtonT == 0 ); + + HXxSize mySize; + + HXxWindow* pParentWindow = NULL; + if(GetParentSite()) + { + pParentWindow = GetParentSite()->GetWindow(); + } + if(pParentWindow) + { + GetParentSite()->GetSize(mySize); + } + + HX_ASSERT( pParentWindow ); + HX_ASSERT( pParentWindow->window != 0 ); + + if( m_ScrollHorizButtonR ) + { + // if the other bar already exists, don't overlap it! + mySize.cy -= SCROLL_BAR_WIDTH; + } + + + m_ptScrollVertPosT.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH; + m_ptScrollVertPosT.y = m_topleft.y; + + m_ptScrollVertPosB.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH; +#ifndef _ARROWS_SIDE_BY_SIDE + m_ptScrollVertPosB.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH; +#else + m_ptScrollVertPosB.y = m_topleft.y+SCROLL_BAR_WIDTH; +#endif + + Display* dis = (Display*)GetWindow()->display; + XLockDisplay(dis); + Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) ); + XUnlockDisplay(dis); + Pixel greyPixel = blackPixel; + Colormap cmap = HXGetXColormap((Display*)GetWindow()->display, + (Window)GetWindow()->window); + XColor color; + XLockDisplay(dis); + XParseColor(dis, cmap, "gray", &color); + XUnlockDisplay(dis); + HXFindBestXColor(dis, cmap, &color); + greyPixel = color.pixel; + + HX_ASSERT( GetWindow() ); + XLockDisplay(dis); + m_ScrollVertButtonT = XCreateSimpleWindow( dis, + (Window)pParentWindow->window, + m_ptScrollVertPosT.x, m_ptScrollVertPosT.y, + SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH, + 1, + blackPixel, + greyPixel + ); + m_ScrollVertButtonB = XCreateSimpleWindow( dis, + (Window)pParentWindow->window, + m_ptScrollVertPosB.x, m_ptScrollVertPosB.y, + SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH, + 1, + blackPixel, + greyPixel + ); + XUnlockDisplay(dis); + + HX_ASSERT( m_ScrollVertButtonB && m_ScrollVertButtonT ); + +} + +// +// Inherited CHXBaseSite methods. +// +void CHXExSite::_NeedWindowedSite() +{ +#ifdef _DEBUG + fprintf( stderr, "CHXExSite::_NeedWindowedSite do something here....\n" ); +#endif + //Nothing to do on unix.... +} + +void CHXExSite::_AttachWindow() +{ +#if 1 + void* pDummy=NULL; + + if (m_pRootSurface) + { /* Replace CUnixRootSurf with my own CExRootSurf */ + HX_RELEASE(m_pRootSurface); + m_pRootSurface = new CExRootSurf(m_pContext, this, m_on_new_frame_cb, m_context); + m_pRootSurface->AddRef(); + } + + if(!z_mapSiteToWindow.Lookup((void*)this, pDummy)) + { + z_mapSiteToWindow.SetAt((void*)this, (void*)m_pWindow); + } + + //Set the display variable. + if( m_pWindow->display == NULL ) + { + HX_ASSERT(zm_display); + m_pWindow->display = zm_display; + } + + //Now that we have a window be sure to init the CExRootSurf. + //this lets it set up the display, colormap, etc. + ((CExRootSurf*)m_pRootSurface)->Init(); +#endif +} + +void CHXExSite::_DetachWindow() +{ +#if 1 + void* pDummy; + + if (z_mapSiteToWindow.Lookup((void*)this, pDummy)) + { + z_mapSiteToWindow.RemoveKey((void*)this); + } +#endif +} + +void* CHXExSite::_Create(void* pParentWindow, UINT32 style) +{ + HRESULT result = HXR_OK; + if( m_pWindow && m_pWindow->window ) + { + HX_ASSERT( "We already have created a window"==NULL); + return NULL; + } + + if (pParentWindow==NULL || style) + { + m_bIsChildWindow = FALSE; + } + else + { + m_bIsChildWindow = TRUE; + } + + if( _OpenXDisplay(NULL) != HXR_OK ) + { + return NULL; + } + return (void*)CreateXWindow((Window)pParentWindow); +} + + +void CHXExSite::_Destroy(HXxWindow* pWindow) +{ + _DestroySliders(); + HXxWindow* pWin = GetWindow(); + Display* pDis = (Display*)(pWin?pWin->display:NULL); + if( pDis ) + { + XLockDisplay(pDis); + XDestroyWindow( pDis, (Window)pWindow->window ); + XUnlockDisplay(pDis); + } +} + +void CHXExSite::_SetSize(HXxSize size) +{ + HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window); + //The scroll bars get resized also... + _DestroySliders(); + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XResizeWindow(pDis, + (Window) m_pWindow->window, + size.cx, + size.cy); + XUnlockDisplay(pDis); +} + +void CHXExSite::_SetPosition(HXxPoint position) +{ + HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window); + _DestroyScrollButtons(); + XLockDisplay((Display*) m_pWindow->display); + XMoveWindow((Display*)m_pWindow->display, + (Window)m_pWindow->window, + position.x, + position.y); + XUnlockDisplay((Display*) m_pWindow->display); +} + +void CHXExSite::_DamageRect(HXxRect rect) +{ + if(GetWindow()) + { + m_bDamaged = TRUE; + } + return; +} + +void CHXExSite::_DamageRegion(HXxRegion rect) +{ + if(GetWindow()) + { + m_bDamaged = TRUE; + } + return; +} + +void CHXExSite::_SendOSUpdateMessage() +{ + //We need to redraw our window here, m_pWindow. +} + +void CHXExSite::_ShowSite(HXBOOL bShow) +{ + if( bShow ) + { + _MapScrollButtons(); + } + else + { + _UnmapScrollButtons(); + } + //do nothing.... +} + +HXBOOL CHXExSite::_AtSystemTime() +{ + return TRUE; +} + +void CHXExSite::_GetDeviceCaps( void* hdc, + UINT16& uBitsPerPixel, + UINT16& uHorzRes, + UINT16& uVertRes ) +{ + Screen* pScreen = NULL; + HXxWindow* pWin = GetWindow(); + HX_ASSERT( pWin ); + if( pWin ) + { + Display* dis = (Display*)pWin->display; + HX_ASSERT( dis ); + if( dis ) + { + Display* pDisp = (Display*)GetWindow()->display; + XLockDisplay(pDisp); + pScreen = DefaultScreenOfDisplay(pDisp); + XUnlockDisplay(pDisp); + + uBitsPerPixel = pScreen->root_depth; + uHorzRes = pScreen->width; + uVertRes = pScreen->height; + } + } +} + +void CHXExSite::_GetWindowRect(HXxRect* destRect) +{ + HX_ASSERT( "Doesn't seem to be used anywhere"==NULL ); +} + +void CHXExSite::_DestroySliders() +{ + _DestroyScrollButtons(); +} + +void CHXExSite::_ForwardUpdateEvent(HXxEvent* pEvent) +{ + GC gc = NULL; + AddRef(); + + HX_ASSERT(GetWindow()->window); + HX_ASSERT(m_pUser); + if(m_bIsChildWindow) + { + //Create a clip region that excludes our higher z-order + //siblings and is clipped to our parent. + if( !m_bRegionIsValid ) + { + RecomputeClip(); + } + + // The problem is that regions are locked to the origin so we + // will need to reverse shift the region before we set the + // origin of the graph port! get the GC from the video surface + gc = ((CExRootSurf*)m_pRootSurface)->GetGC(); + HX_ASSERT( gc ); + + //Actually setup our clip region + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XSetRegion( pDis, gc, (Region) m_Region ); + XUnlockDisplay(pDis); + } + + XEvent* pXEvent = (XEvent*) pEvent->param2; + XExposeEvent* exposeEvent = (XExposeEvent*) pXEvent; + + // get the rect for this site with respect to our parent + HXRECTANGLE exposedRect = { exposeEvent->x, + exposeEvent->y, + exposeEvent->width, + exposeEvent->height }; + HXREGION* exposedRegion = HXCreateRegion(); + HXUnionRectWithRegion(&exposedRect, exposedRegion, exposedRegion); + + // does the site intersect the current clipping region? + HXREGION* resultRegion = HXCreateRegion(); + HXIntersectRegion(exposedRegion, m_Region, resultRegion); + HXBOOL bSiteIntersectsExposed = (HXEmptyRegion(resultRegion)==FALSE); + + HXDestroyRegion(resultRegion); + HXDestroyRegion(exposedRegion); + + // if the exposed region intersects the sites clipping region + if(bSiteIntersectsExposed) + { + m_pUser->HandleEvent(pEvent); + } + + //If the user doesn't handle the standard update event then send + //them the cross platform HX_SURFACE_UPDATE event don't damage the + //original event structure + if(!pEvent->handled && m_pUser ) + { + HX_ASSERT(GetWindow()); + HXxEvent event; + event.event = HX_SURFACE_UPDATE; + event.window = GetWindow()->window; + event.param1 = m_pVideoSurface; + event.param2 = GetWindow(); + event.result = 0; + event.handled = FALSE; + m_pUser->HandleEvent(&event); + pEvent->handled = event.handled; + } + + + //reset the gc to use no region + if(m_bIsChildWindow && gc) + { + Display* pDisp = (Display*)GetWindow()->display; + XLockDisplay(pDisp); + XSetClipMask(pDisp, gc, None); + XUnlockDisplay(pDisp); + } + + //Handle the drawing of our arrows... + _DrawArrows(); + + //Now do all our children.... + CHXMapPtrToPtr::Iterator i = m_ChildrenMap.Begin(); + for(;i!=m_ChildrenMap.End();++i) + { + CHXExSite* pSite = (CHXExSite*) *i; + pSite->_ForwardUpdateEvent(pEvent); + } + + Release(); +} + +UINT32 CHXExSite::_MapKeySymToHXVK(KeySym sym, UINT32& uFlags ) +{ + //XXXgfw if we add the extended flag in the HX_KEYBOARD event + //structure then we can modify the flags here to show that these + //keys are 'extended' in the windows sense. + UINT32 ulRet = 0; + switch( sym ) + { + case XK_Shift_R: + ulRet = XK_Shift_L; + break; + case XK_Alt_R: + ulRet = XK_Alt_L; + break; + case XK_KP_Home: + ulRet = XK_Home; + break; + case XK_KP_Next: + ulRet = XK_Next; + break; + case XK_KP_Prior: + ulRet = XK_Prior; + break; + case XK_KP_Enter: + ulRet = XK_Return; + break; + case XK_KP_End: + ulRet = XK_End; + break; + case XK_KP_Begin: + ulRet = XK_Begin; + break; + case XK_KP_Left: + ulRet = XK_Left; + break; + case XK_KP_Up: + ulRet = XK_Up; + break; + case XK_Control_R: + ulRet = XK_Control_L; + break; + case XK_KP_Right: + ulRet = XK_Right; + break; + case XK_KP_Down: + ulRet = XK_Down; + break; + case XK_KP_Insert: + ulRet = XK_Insert; + break; + case XK_KP_Delete: + ulRet = XK_Delete; + break; + default: + ulRet = sym; + break; + } + if( ulRet != sym ) + { + //We have mapped a key from Right hand side, keypad, arrows + //or other parts of an extended keyboard. Set the flag. + uFlags |= HX_EXTENDED_KEY_MASK; + } + return ulRet; +} + + +HXBOOL CHXExSite::_ConvertToHXEvent(HXxEvent* pEvent ) +{ + // get original events info from pEvent + XEvent* pXEvent = (XEvent*) pEvent->param2; + XButtonEvent* buttonEvent = (XButtonEvent*) pXEvent; + + + //=============================================================== + // Convert all other event to RMA generic events and pass back. + //=============================================================== + if( ((pEvent->event == ButtonPress) || + (pEvent->event == ButtonRelease) || + (pEvent->event == MotionNotify ) || + (pEvent->event == EnterNotify) || + (pEvent->event == FocusIn) || + (pEvent->event == FocusOut) || + (pEvent->event == KeyPress) || + (pEvent->event == KeyRelease) || + (pEvent->event == LeaveNotify)) + ) + { + // set modifier flags for all events.... + UINT32 flags = 0; + + // create new HXxEvent + HXxEvent theEvent; + + //XXXgfw ouch.... + static HXxPoint realPt = {0,0}; + + //Init certain members. + memset(&theEvent, 0, sizeof(HXxEvent)); + theEvent.window = pEvent->window; + theEvent.handled = FALSE; + + // + // NOTE: + // + // theEvent must be filled in by *ALL* event types. + // theEvent will be memcopied into the pEvent passed + // back to the basesite at the end of the method. + // + + //================================================== + // LEAVE NOTIFY EVENT + //================================================== + if( pEvent->event==LeaveNotify) + { + if( m_pTopLevelSite->m_pMouseInSite ) + { + HXxPoint oobPoint; + oobPoint.x = -1; + oobPoint.y = -1; + HXxEvent Outevent = { HX_MOUSE_LEAVE, + m_pWindow->window, + (void*)&oobPoint, + 0, 0, + FALSE }; + m_pTopLevelSite->m_pMouseInSite->EventOccurred(&Outevent); + m_pTopLevelSite->m_pMouseInSite = NULL; + } + pEvent->handled=TRUE; + return TRUE; + } + + //================================================== + // ENTER NOTIFY EVENT + //================================================== + if( pEvent->event==EnterNotify) + { + pEvent->handled=TRUE; + return TRUE; + } + + //================================================== + // KEY PRESS/RELEASE EVENT + //================================================== + if ( pEvent->event == KeyPress || pEvent->event==KeyRelease ) + { + XKeyEvent* pKeyEvent = (XKeyEvent*)pEvent->param2; + + // + //Set the event type + // + theEvent.event = pEvent->event==KeyPress?HX_KEY_DOWN:HX_KEY_UP; + + // + // Fill in the scan/key code. + // + flags = pKeyEvent->keycode; + flags &= 0x000000ff; //the scan code only gets bits 0-7 + + // + // build key modifier list... + // + if( pKeyEvent->state & ShiftMask ) + flags |= HX_SHIFT_MASK; + + if( pKeyEvent->state & ControlMask ) + flags |= HX_CTRL_MASK; + + if( pKeyEvent->state & LockMask ) + flags |= HX_CAPS_LOCK_MASK; + + if( pKeyEvent->state & Mod1Mask) + flags |= HX_ALT_MASK; + + if( pKeyEvent->state & Mod2Mask) + flags |= HX_NUM_LOCK_MASK; + + if( pKeyEvent->state & Mod5Mask) + flags |= HX_SCROLL_LOCK_MASK; + + // + //Store the char pressed. + // + KeySym sym; + char szBuf[10]; /* Flawfinder: ignore */ + int nNum; + + //Save the state of the keys... + unsigned int unSave = pKeyEvent->state; + pKeyEvent->state=0; + + //Lookup the key without any state. + nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL ); + if( nNum > 0 ) + { + theEvent.param1 = (void*)*szBuf; + } + else + { + theEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags); + flags |= HX_VIRTUAL_KEY_MASK; + } + //restore the state of the event + pKeyEvent->state = unSave; + + //Set the flags... + theEvent.param2 = (void*)flags; + + //Check for HX_CHAR needed or not. + if( theEvent.event == HX_KEY_DOWN ) + { + //We have to send an extra HX_CHAR event + HXxEvent extraEvent; + memcpy( &extraEvent, &theEvent, sizeof( extraEvent ) ); /* Flawfinder: ignore */ + + //Change the type. + extraEvent.event = HX_CHAR; + + // + //Change the keycode to an translated ascii char. + // + KeySym sym; + char szBuf[10]; /* Flawfinder: ignore */ + int nNum; + + nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL ); + + if( nNum > 0 ) + { + extraEvent.param1 = (void*)*szBuf; + } + else + { + extraEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags); + flags |= HX_VIRTUAL_KEY_MASK; + } + extraEvent.param2 = (void*)flags; + + // + // Now send the extra event.... + // + CHXBaseSite::EventOccurred(&extraEvent); + } + } + + //================================================== + // FOCUS OUT EVENT + //================================================== + if ( pEvent->event == FocusOut ) + { + theEvent.event = HX_LOSE_FOCUS; + } + + if ( pEvent->event == FocusIn ) + { + theEvent.event = HX_SET_FOCUS; + } + + //================================================== + // MOUSE MOVE EVENT + //================================================== + if( pEvent->event == MotionNotify ) + { + XMotionEvent* pp = (XMotionEvent*)pEvent->param2; + theEvent.event = HX_MOUSE_MOVE; + + if( pp->state&Button1Mask ) + flags |= HX_PRIMARY_BUTTON; + + if( pp->state&Button2Mask ) + flags |= HX_CONTEXT_BUTTON; + + if( pp->state&Button3Mask ) + flags |= HX_THIRD_BUTTON; + + if(pp->state & ShiftMask) + flags |= HX_SHIFT_KEY; + + if(pp->state & ControlMask) + flags |= HX_CTRL_KEY; + + if(pp->state & Mod1Mask) + flags |= HX_ALT_COMMAND_KEY; + + theEvent.param2 = (void*) flags; + + //Grab the X and Y. + theEvent.param1 = (void*) &realPt; + realPt.x = pp->x; + realPt.y = pp->y; + } + + //================================================== + // BUTTON PRESS/RELEASE EVENT + //================================================== + if((pEvent->event == ButtonPress) || (pEvent->event == ButtonRelease)) + { + // remap event + if (pEvent->event == ButtonPress) + { + if (buttonEvent->button == Button3) + theEvent.event = HX_CONTEXT_BUTTON_DOWN; + else + theEvent.event = HX_PRIMARY_BUTTON_DOWN; + } + else if (pEvent->event == ButtonRelease) + { + if (buttonEvent->button == Button3) + theEvent.event = HX_CONTEXT_BUTTON_UP; + else + theEvent.event = HX_PRIMARY_BUTTON_UP; + } + + if(buttonEvent->state & ShiftMask) + flags |= HX_SHIFT_KEY; + + if(buttonEvent->state & ControlMask) + flags |= HX_CTRL_KEY; + + theEvent.param2 = (void*) flags; + + //Grab the X and Y. + theEvent.param1 = (void*) &realPt; + realPt.x = buttonEvent->x; + realPt.y = buttonEvent->y; + } + + //Copy the new event back into the passed in one for + //all events that fall through here... + memcpy( pEvent, &theEvent, sizeof(HXxEvent) ); /* Flawfinder: ignore */ + +#if defined(_DEBUG) + //If the users presses control-primary button + //dump info on all sites. If shift-context, then + //just this site. + if( (buttonEvent->state&ControlMask)&& + (theEvent.event==HX_PRIMARY_BUTTON_DOWN)) + { + DisplayAllSiteData(); + } + if( (buttonEvent->state&ShiftMask)&& + (theEvent.event==HX_PRIMARY_BUTTON_DOWN)) + { + DisplaySiteData(""); + } +#endif + } + return pEvent->handled; +} + + +void CHXExSite::CheckColorSettings() +{ +#if !defined(HELIX_FEATURE_HARDWARE_COLOR_CONTROLS) + CHXBaseSite::CheckColorSettings(); +#else + CUnixSurf* pSurf = (CUnixSurf*)m_pVideoSurface; + if( !pSurf->HasHWColorConrols() ) + { + CHXBaseSite::CheckColorSettings(); + } + else + { + pSurf->SetHWColorControls(); + + //We do all color stuff except sharpmess in hardware. + float fCurrentSharpness; + INT16 bInterpolate; + zm_pColorAcc->GetSharpnessAdjustments(&fCurrentSharpness, &bInterpolate); + + if (fCurrentSharpness != m_fSharpness) + { + zm_pColorAcc->SetSharpnessAdjustments(m_fSharpness, FALSE); + } + } +#endif +} + +// +// OK, here it is. Take care of any OS specific duties, like scrollbar +// stuff and expose events. Then, if the event isn't handled, convert +// to an RMA event and return. +HXBOOL CHXExSite::_HandleOSEvents(HXxEvent* pEvent) +{ + HXxPoint position = {0, 0}; + HXxPoint point; + + if( NULL==pEvent ) + { + return FALSE; + } + + return TRUE; + +#if defined(_DEBUG) && 0 +// fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser ); + switch( pEvent->event ) + { + case HX_MOUSE_LEAVE: + fprintf( stderr, "HX_MOUSE_LEAVE\n" ); + break; +// case HX_MOUSE_MOVE: +// point.x = ((HXxPoint*)pEvent->param1)->x; +// point.y = ((HXxPoint*)pEvent->param1)->y; +// fprintf( stderr, "HX_MOUSE_MOVE: %d %d\n", point.x, point.y ); +// break; + case HX_MOUSE_ENTER: + fprintf( stderr, "HX_MOUSE_ENTER\n" ); + break; +// case MotionNotify: +// point.x = ((XMotionEvent*)pEvent->param2)->x; +// point.y = ((XMotionEvent*)pEvent->param2)->y; +// fprintf( stderr, "MotionNotify: %d %d\n", point.x, point.y ); +// break; + case Expose: + fprintf( stderr, "Expose\n" ); + break; + case EnterNotify : + fprintf( stderr, "EnterNotify\n" ); + break; + case LeaveNotify: + fprintf( stderr, "LeaveNotify\n" ); + break; + case KeyPress: + fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser ); + fprintf( stderr, "Keypress\n\n" ); + break; + case KeyRelease: + fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser ); + fprintf( stderr, "KeyRelease\n" ); + break; + default: + fprintf( stderr, "Other\n" ); + break; + } +#endif + + //Find the ConfigureNotify events so we can drop to RGB from + //overlay while we move.... +// if( pEvent->event == ConfigureNotify && this==m_pTopLevelSite ) +// { +// XConfigureEvent* pev = (XConfigureEvent*)pEvent->param2; +// if( m_pWindow && pev->window == (Window)m_pWindow->window ) +// { +// HXxPoint p; +// _GetPositionRelativeToActualWindow( p ); +// // fprintf( stderr, "wint %p -- x,y width, height: %d %d %d %d \n", +// // pev->window, +// // pev->x, pev->y, pev->width, pev->height); +// // fprintf( stderr, "size of site: %d %d\n", m_size.cx, m_size.cy); +// // fprintf( stderr, "pos of site: %d %d\n", m_topleft.x, m_topleft.y); +// m_pTopLevelSite->m_pMutex->Lock(); +// m_pTopLevelSite->SiteMoving(0, 0); +// m_pTopLevelSite->m_nLastMoveTime = HX_GET_TICKCOUNT(); +// m_pTopLevelSite->ScheduleCallback(MOUSE, 100); +// m_pTopLevelSite->m_pMutex->Unlock(); +// } +// } + + //See if we should drop out of full screen + if( pEvent->event == FocusOut && IsFullScreen() && !m_bIgnoreFocusOutInFS ) + { +// fprintf( stderr, "_HandleOSEvents: focus out: " ); +// XEvent* pXEvent = (XEvent*) pEvent->param2; +// XFocusChangeEvent* event = (XFocusChangeEvent*) pXEvent; +// switch( event->mode ) +// { +// case NotifyAncestor: +// fprintf( stderr, "NotifyAncestor\n" ); +// break; +// case NotifyVirtual: +// fprintf( stderr, "NotifyVirtual\n" ); +// break; +// case NotifyInferior: +// fprintf( stderr, "NotifyInferior\n" ); +// break; +// case NotifyNonlinear: +// fprintf( stderr, "NotifyNonlinear\n" ); +// break; +// case NotifyNonlinearVirtual: +// fprintf( stderr, "NotifyNonlinearVirtual\n" ); +// break; +// case NotifyPointer: +// fprintf( stderr, "NotifyPointer\n" ); +// break; +// case NotifyPointerRoot: +// fprintf( stderr, "NotifyPointerRoot\n" ); +// break; +// case NotifyDetailNone: +// fprintf( stderr, "NotifyDetailNone\n" ); +// break; +// default: +// fprintf( stderr, "screwed.....\n" ); +// } + ExitFullScreen(); + } + + +#if defined(_DEBUG) && defined(TEST_FULL_SCREEN) + if( pEvent->event == KeyPress ) + { + KeySym sym; + char szBuf[10]; /* Flawfinder: ignore */ + int nNum; + + //Lookup the key without any state. + nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL ); + if( nNum > 0 ) + { + if( 'f' == szBuf[0] && IsFullScreen() ) + { + //Exit full screen if 'f' is pressed..... + m_pTopLevelSite->ExitFullScreen(); + } + else if( 'f' == szBuf[0] && !IsFullScreen() ) + { + //Enter full screen if 'f' is pressed..... + m_pTopLevelSite->EnterFullScreen(); + } + + } + + } +#endif + +#if defined(_DEBUG) && defined(_TEST_COLOR_CONTROLS) + if( pEvent->event == KeyPress ) + { + KeySym sym; + char szBuf[10]; /* Flawfinder: ignore */ + int nNum; + + //Lookup the key without any state. + nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL ); + if( nNum > 0 ) + { + if( 'b' == szBuf[0] ) + { + SetBrightness( GetBrightness()-.05); + } + if( 'B' == szBuf[0] ) + { + SetBrightness( GetBrightness()+.05); + } + + if( 'c' == szBuf[0] ) + { + SetContrast( GetContrast()-.05); + } + if( 'C' == szBuf[0] ) + { + SetContrast( GetContrast()+.05); + } + + if( 'h' == szBuf[0] ) + { + SetHue( GetHue()-.05); + } + if( 'H' == szBuf[0] ) + { + SetHue( GetHue()+.05 ); + } + + if( 's' == szBuf[0] ) + { + SetSaturation( GetSaturation()-.05); + } + if( 'S' == szBuf[0] ) + { + SetSaturation( GetSaturation()+.05); + } + fprintf( stderr, "colors %f %f %f %f\n", + GetBrightness(), + GetContrast(), + GetSaturation(), + GetHue()); + } + + } +#endif + + //Exit full screen on ESC pressed...... + if( pEvent->event == KeyPress ) + { + KeySym sym; + char szBuf[10]; /* Flawfinder: ignore */ + int nNum; + + //Lookup the key without any state. + nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL ); + if( nNum > 0 ) + { + if( 27 == (int)szBuf[0] && IsFullScreen() ) + { + //Exit full screen if esc is pressed..... + m_pTopLevelSite->ExitFullScreen(); + } + } + } + + //Find out if this is an event we are interested in. Make sure we + //are visible, it isn't a button, expose or FocusIn event and also + //make sure it is headed for our window. + if (!_ShouldProcess(pEvent)) + { + return FALSE; + } + + + if(m_pUser && GetWindow() && GetWindow()->window) + { + //Do not send an update event to a hidden site. + if( pEvent->event == Expose || + pEvent->event == FocusIn || + pEvent->event == HX_SURFACE_UPDATE ) + { + if( (m_ScrollVertButtonT || m_ScrollHorizButtonR) && IsSiteVisible() ) + { + _DrawArrows(); + } + _ForwardUpdateEvent(pEvent); + return TRUE; + } + else + { + // get original events info from pEvent + XEvent* pXEvent = (XEvent*) pEvent->param2; + XButtonEvent* buttonEvent = (XButtonEvent*) pXEvent; + + + //XXXgfw all this code sucks! It really need to be written + //for just native events or RMA events. With the change to a + //common site it is all screwed up. I am leaving it for now + //so we can get on with transparancy but get back to it! + + //If the user clicks MB1 on a scroll button, handle it here and + //don't pass it up or let the user handle the event. + //Hit detection here. + + //////////////////////////////////////////////////////// + // BEGIN SCROLLING GARBAGE + //////////////////////////////////////////////////////// + if( + ((pEvent->event==ButtonPress || pEvent->event==ButtonRelease) && + buttonEvent->button==Button1) && + (m_ScrollHorizButtonL || m_ScrollVertButtonB ) + ) + { + int buttonX=0; + int buttonY=0; + + if( pEvent->event==ButtonRelease ) + { + if( m_bScrollingInProgress ) + { + m_bScrollingInProgress = FALSE; + m_nScrollDir = 0; + return TRUE ; + } + } + else + { + buttonX = buttonEvent->x; + buttonY = buttonEvent->y; + + HXBOOL bPointInSite = FALSE; + if( m_Region ) + bPointInSite = HXPointInRegion(m_Region, buttonX, buttonY); + + if( bPointInSite ) + { + if( m_ScrollHorizButtonL ) + { + if( _InButton( m_ptScrollHorizPosL, buttonX, buttonY )) + { + m_bScrollingInProgress = TRUE; + m_nScrollDir = 1; + } + if( _InButton( m_ptScrollHorizPosR, buttonX, buttonY )) + { + m_bScrollingInProgress = TRUE; + m_nScrollDir = 2; + } + } + if( m_ScrollVertButtonT ) + { + if( _InButton( m_ptScrollVertPosT, buttonX, buttonY )) + { + m_bScrollingInProgress = TRUE; + m_nScrollDir = 3; + } + if( _InButton( m_ptScrollVertPosB, buttonX, buttonY )) + { + m_bScrollingInProgress = TRUE; + m_nScrollDir = 4; + } + } + } + } + + if( (m_ScrollHorizButtonL||m_ScrollVertButtonT) && m_bScrollingInProgress) + { + int xx=0; + int yy=0; + HXxWindow* pParentWindow = GetParentSite()->GetWindow(); + //Make it scroll 10% of the parent window each click. + HXxSize sizeTmp; + GetParentSite()->GetSize(sizeTmp); + + //Set it to a percentage of the slider range. + int incX = sizeTmp.cx/10; + int incY = sizeTmp.cy/10; + + HX_ASSERT( pParentWindow ); + + xx = m_XSliderPos; + yy = m_YSliderPos; + + if( m_nScrollDir == 1 ) + xx-=incX; + if( m_nScrollDir == 2 ) + xx+=incX; + if( m_nScrollDir == 3 ) + yy-=incY; + if( m_nScrollDir == 4 ) + yy+=incY; + + if( xx > m_size.cx-sizeTmp.cx ) + xx = m_size.cx-sizeTmp.cx; + if( yy > m_size.cy-sizeTmp.cy) + yy = m_size.cy-sizeTmp.cy; + + if( xx < 0 ) + xx = 0; + if( yy < 0 ) + yy = 0; + + m_XSliderPos = xx; + m_YSliderPos = yy; + + HXxRect rect; + DamageRect(rect); + + InternalForceRedraw(); + } + //Only throw away the event if it had something to do with + //scolling. + if( m_bScrollingInProgress ) + { + m_bScrollingInProgress = FALSE; + m_nScrollDir = 0; + return TRUE; + } + } + //////////////////////////////////////////////////////// + // END SCROLLING GARBAGE + //////////////////////////////////////////////////////// + point.x = -1; + point.y = -1; + + if( pEvent->event == MotionNotify) + { + point.x = ((XMotionEvent*)pXEvent)->x; + point.y = ((XMotionEvent*)pXEvent)->y; + } + else if( pEvent->event == ButtonPress ) + { + point.x = ((XMotionEvent*)pXEvent)->x; + point.y = ((XMotionEvent*)pXEvent)->y; + } + + // + //Give the user a chance at the native event. + // + if( m_RegionWithoutChildren && HXPointInRegion(m_RegionWithoutChildren, point.x, point.y )) + { + if( m_Region && HXPointInRegion(m_Region, point.x, point.y) ) + { + if (m_pUser) + m_pUser->HandleEvent(pEvent); + } + else + { + INT32 handledCount = 0; + INT32 mapCount = 0; + + //try send this to all of our children + _unixsitecpp1: + mapCount = m_ChildrenMap.GetCount(); + CHXMapPtrToPtr::Iterator i; + for(i=m_ChildrenMap.Begin() ; i!=m_ChildrenMap.End() ; ++i) + { + CHXBaseSite* pSite = (CHXBaseSite*) *i; + pSite->_HandleOSEvents(pEvent); + if (pEvent->handled) + { + break; + } + handledCount+=pEvent->handled; + pEvent->handled=0; + + if (m_ChildrenMap.GetCount() != mapCount) + { + goto _unixsitecpp1; + } + } + if (handledCount) + { + pEvent->handled = 1; + } + HX_ASSERT(handledCount<2); + } + } + pEvent->handled=FALSE; + } + } + + return FALSE; +} + +void CHXExSite::_GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2) +{ + //XXXgfw Not needed on UNIX I guess??? +} + +void CHXExSite::_GenerateSetCursorEvent() +{ +#ifdef _DEBUG + fprintf( stderr, "CHXExSite::_GenerateSetCursorEvent\n" ); +#endif + //XXXgfw do we need this?? +} + +void CHXExSite::_TryCreateXSlider() +{ +#if 0 + if( !m_ScrollHorizButtonL && IsSiteVisible() ) + _CreateHorizScrollBar(); +#endif +} + +void CHXExSite::_SetXSliderValues(INT32 range, INT32 pageSize) +{ + //XXXgfw this is a do nothing as long as we only have + //scroll buttons on unix and not real scroll bars. +} + +void CHXExSite::_TryCreateYSlider() +{ +#if 0 + if( !m_ScrollVertButtonT && IsSiteVisible() ) + _CreateVertScrollBar(); +#endif +} + +void CHXExSite::_SetYSliderValues(INT32 range, INT32 pageSize) +{ + //XXXgfw this is a do nothing as long as we only have + //scroll buttons on unix and not real scroll bars. +} + +void CHXExSite::_GetSystemSizeOfSliders(INT32* pWidth, INT32* pHeight) +{ +#if 0 + *pWidth = *pHeight = SCROLL_BAR_WIDTH; +#endif +} + +HXBOOL CHXExSite::_IsWindowVisible() +{ +#if 0 + HX_RESULT retVal = FALSE; + //XXXgfw do this for now... + retVal = IsSiteVisible(); + return retVal; +#else + return FALSE; +#endif + +} + +void CHXExSite::_ShowXSlider(HXBOOL bShow) +{ +#if 0 + if( GetWindow() ) + { + if( bShow ) + _MapHorzScroll(); + else + _UnmapHorzScroll(); + } +#endif +} + +void CHXExSite::_MoveXSlider( INT32 left, + INT32 top, + INT32 right, + INT32 bottom, + HXBOOL bRedraw ) +{ + //Do nothing right now.... +} + +void CHXExSite::_ShowYSlider(HXBOOL bShow) +{ +#if 0 + if( GetWindow() ) + { + if( bShow ) + _MapVertScroll(); + else + _UnmapVertScroll(); + } +#endif +} + +void CHXExSite::_MoveYSlider( INT32 left, + INT32 top, + INT32 right, + INT32 bottom, + HXBOOL bRedraw) +{ + //do nothing right now... +} + +HXBOOL CHXExSite::_DoesXSliderExist() +{ + return FALSE; +// return (m_ScrollHorizButtonL!=0); +} + +void* CHXExSite::_GetContainingWindow() +{ + //XXXgfw Do we need this??? + return NULL; +} + +void CHXExSite::_GetCursorPos(HXxPoint* pPoint) +{ + //Return the cursor pos in screen coords. + Window rootWin; + Window childWin; + int rootX=0; + int rootY=0; + int childX=0; + int childY=0; + unsigned int mask=0; + Bool ret=FALSE; + + HX_ASSERT(GetWindow()); + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + ret = XQueryPointer(pDis, + (Window)GetWindow()->window, + &rootWin, + &childWin, + &rootX, &rootY, + &childX, &childY, + &mask); + XUnlockDisplay(pDis); + + if(ret) + { + pPoint->x = rootX; + pPoint->y = rootY; + } +} +void* CHXExSite::_GetWindowWithCursor() +{ +#if 0 + //Return the cursor pos in screen coords. + void* pRet = NULL; + int rootX = 0; + int rootY = 0; + int childX= 0; + int childY= 0; + unsigned int mask = 0; + Bool ret = FALSE; + Window rootWin; + Window childWin; + + HX_ASSERT(GetWindow()); + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + ret = XQueryPointer(pDis, + (Window)GetWindow()->window, + &rootWin, + &childWin, + &rootX, &rootY, + &childX, &childY, + &mask); + XUnlockDisplay(pDis); + + if(ret) + { + pRet = (void*)childWin; + } + return pRet; +#else + HX_ASSERT( "Not implemented..." == NULL ); + return NULL; +#endif +} + +void CHXExSite::_MapPointToOSWindow(HXxPoint* pPt, void** pWindowHandle) +{ + //XXXgfw we could query the window tree and traverse down but that + //is really slow and this isn't used right now. + HX_ASSERT( "Not implemented..." == NULL ); +} + +void CHXExSite::_ReInitPrimarySurface() +{ + //Nothing to do in unix here right? +} + +HXBOOL CHXExSite::_MoveWindow( void* win, + INT32 X, + INT32 Y, + INT32 nWidth, + INT32 nHeight, + HXBOOL bRepaint) +{ +#if 0 + //XXXgfw we still have to do bRepaint.... + HX_ASSERT( m_pWindow && m_pWindow->window && m_pWindow->display); + _DestroyScrollButtons(); + XLockDisplay((Display*) m_pWindow->display); + XMoveResizeWindow( (Display*)m_pWindow->display, + (Window)m_pWindow->window, + X, + Y, + nWidth, + nHeight + ); + XUnlockDisplay((Display*) m_pWindow->display); +#else + HX_ASSERT( "Not implemented..." == NULL ); +#endif + return TRUE; +} + +HXBOOL CHXExSite::_UpdateWindow(void* hWnd) +{ + //We need to generate a repaint here of the window.... + return TRUE; +} + +HXBOOL CHXExSite::_ShowWindow(void* hWnd, INT32 nCmdShow) +{ +#if 0 + HX_ASSERT( nCmdShow==HX_SHOW_WINDOW || nCmdShow==HX_HIDE_WINDOW); + if( !m_pWindow || !m_pWindow->window || !m_pWindow->display ) + return FALSE; + + if( nCmdShow == HX_SHOW_WINDOW ) + { + _MapScrollButtons(); + XLockDisplay((Display*) m_pWindow->display); + XMapWindow( (Display*)m_pWindow->display, (Window)m_pWindow->window ); + XUnlockDisplay((Display*) m_pWindow->display); + } + else + { + _UnmapScrollButtons(); + XLockDisplay((Display*) m_pWindow->display); + XUnmapWindow( (Display*)m_pWindow->display, (Window)m_pWindow->window ); + XUnlockDisplay((Display*) m_pWindow->display); + } +#endif + return TRUE; +} + +HXBOOL CHXExSite::_SetWindowPos(void* hWnd, + void* hWndInsertAfter, + INT32 X, + INT32 Y, + INT32 cx, + INT32 cy, + INT32 uFlags) +{ +#ifdef _DEBUG + fprintf( stderr, "Now what on earth is this suppose to do??\n" ); +#endif + return TRUE; +} + +HXBOOL CHXExSite::_SetWindowRgn(void* hWnd, HXREGION* hRgn, HXBOOL bRedraw) +{ +#if 0 + HX_ASSERT( GetWindow() ); + Display* pDis = (Display*)GetWindow()->display; + XLockDisplay(pDis); + XSetRegion( pDis, + (GC)m_pVideoSurface->_GetDC(NULL), + (Region)hRgn + ); + XUnlockDisplay(pDis); + if( bRedraw ) + { + HX_ASSERT("Redraw asked for here"==NULL ); + } +#endif + return TRUE; +} + +void CHXExSite::_SetFocus(void* pWindow) +{ +#if 0 + XWindowAttributes attr; + HXxWindow* pWin = GetWindow(); + + HX_ASSERT(pWin); + HX_ASSERT(pWindow); + + XLockDisplay((Display*) pWin->display); + XGetWindowAttributes((Display*)pWin->display, (Window)pWindow, &attr); + XUnlockDisplay((Display*) pWin->display); + if( attr.map_state == IsViewable ) + { + XLockDisplay((Display*) pWin->display); + XSetInputFocus( (Display*)pWin->display, + (Window)pWindow, + RevertToParent, + CurrentTime + ); + XUnlockDisplay((Display*) pWin->display); + } + + return; +#endif +} + +HX_RESULT CHXExSite::_EnterFullScreen(HXxWindow* pWindow) +{ +#if 0 + HXxWindow* pWin = GetWindow(); + HX_ASSERT( pWin && pWin->display && pWin->display); + HX_ASSERT( this == m_pTopLevelSite ); + + if( 0 != m_winFullScreenWindow || IsFullScreen() ) + { + //We are already in full screen + return HXR_FAIL; + } + + //Create a override redirect window to fill the root. + XSizeHints size_hints; + XLockDisplay((Display*) pWin->display); + Screen* pScreen = XDefaultScreenOfDisplay((Display*)pWin->display); + XUnlockDisplay((Display*) pWin->display); + UINT16 uHorzRes = WidthOfScreen(pScreen); + UINT16 uVertRes = HeightOfScreen(pScreen); + int attrMask = 0; + XSetWindowAttributes attr; + + memset(&attr, 0, sizeof(XSetWindowAttributes)); + attrMask = CWOverrideRedirect | CWBorderPixel | + CWBackPixel | CWCursor; + attr.cursor = None; + attr.override_redirect = True; + XLockDisplay((Display*)pWin->display); + attr.background_pixel = BlackPixel((Display*)pWin->display, + DefaultScreen((Display*)pWin->display)); + attr.border_pixel = BlackPixel((Display*)pWin->display, + DefaultScreen((Display*)pWin->display)); + XUnlockDisplay((Display*)pWin->display); + + size_hints.flags = PPosition | PSize; + size_hints.x = 0; + size_hints.y = 0; + size_hints.width = uHorzRes; + size_hints.height = uVertRes; + + //Create it. + XLockDisplay((Display*) pWin->display); + Window window = XCreateWindow((Display*)pWin->display, + DefaultRootWindow((Display*)pWin->display), + size_hints.x, + size_hints.y, + size_hints.width, + size_hints.height, + 0, + CopyFromParent, + InputOutput, + CopyFromParent, + attrMask, + &attr); + + //Tell the WM about this window. + XSetStandardProperties( (Display*)pWin->display, + window, + "unixfullscreen", + "unixfullscreen", + None, + NULL, 0, + &size_hints + ); + + int result = XSelectInput( zm_display, window, + ButtonPressMask | ButtonReleaseMask | KeyPressMask | + KeyReleaseMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask | ButtonMotionMask | KeymapStateMask | + ExposureMask | StructureNotifyMask | FocusChangeMask + ); + + //Map the window. + XMapWindow((Display*)pWin->display, window); + XUnlockDisplay((Display*) pWin->display); + + + //Get ready to resize the presentation.... + if(m_pTopLevelSite) + { + m_pTopLevelSite->m_bDisableForceRedraw = TRUE; + } + + //Maintain aspect ratio and Scale it. + float fXScale = (float)uHorzRes/(float)(m_size.cx); + float fYScale = (float)uVertRes/(float)(m_size.cy); + float fScale = (fXScaledisplay); + XQueryTree( (Display*)pWin->display, + (Window)pWin->window, + &winRootParent, + &winParent, + &pwinChildren, + &nNumChildren + ); + //Free unused children list. + XFree( pwinChildren ); + XUnlockDisplay((Display*) pWin->display); + + HX_ASSERT( winParent ); + m_winOldParent = winParent; + XLockDisplay((Display*) pWin->display); + XReparentWindow( (Display*)pWin->display, + (Window)pWin->window, + window, + m_ptFullScreenOffset.x, + m_ptFullScreenOffset.y + ); + + //Flush event queue. + XSync((Display*)pWin->display, False); + XUnlockDisplay((Display*) pWin->display); + + //Save it + m_winFullScreenWindow = window; + m_bInFullScreen = TRUE; + + //Now resize it... + SetSize(m_size); + //Redraw the presentation.... + m_pTopLevelSite->m_bDisableForceRedraw = FALSE; + _ForceRedrawAll(); + + //Give it focus.... + _SetFocus( (void*)pWin->window ); + + // now eat all the focusouts that came as a result of this reparent... + XEvent event; + XLockDisplay((Display*) pWin->display); + HXBOOL status = XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window, + FocusOut, &event); + XUnlockDisplay((Display*) pWin->display); + while (m_bWindowCreatedByCreate && status) + { + // just discarding these + XLockDisplay((Display*) pWin->display); + status = XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window, + FocusOut, &event); + XUnlockDisplay((Display*) pWin->display); + } + + //Update the status text... + if(m_pStatusText) + { + m_pStatusText->ParentChangedSize(); + m_pStatusText->Show(); + } + +#else + HX_ASSERT( "Not implemented..." == NULL ); +#endif + return HXR_OK; +} + +HX_RESULT CHXExSite::_ExitFullScreen() +{ +#if 0 + HX_ASSERT( this == m_pTopLevelSite ); + + HXxWindow* pWin = GetWindow(); + + HX_ASSERT( pWin && pWin->display && pWin->window ); + + //Give the window back to the TLC. + + XLockDisplay((Display*) pWin->display); + XReparentWindow( (Display*)pWin->display, + (Window)pWin->window, + m_winOldParent, + m_position.x, m_position.y + ); + XUnlockDisplay((Display*) pWin->display); + + //Just kill our window and take us out of full screen.... + if( 0 != m_winFullScreenWindow ) + { + XLockDisplay((Display*) pWin->display); + XDestroyWindow( (Display*)pWin->display, m_winFullScreenWindow ); + XUnlockDisplay((Display*) pWin->display); + m_winFullScreenWindow = 0; + } + + m_bDisableForceRedraw = TRUE; + + m_bInFullScreen = FALSE; + HXxSize size = {0,0}; + memcpy( &size, &m_PreFullScreenSize, sizeof(HXxSize) ); /* Flawfinder: ignore */ + m_PreFullScreenSize.cx = m_PreFullScreenSize.cy = 0; + + SetSize(size); + _SetFocus( (void*)pWin->window ); + m_ptFullScreenOffset.x = 0; + m_ptFullScreenOffset.y = 0; + + + m_bDisableForceRedraw = FALSE; + _ForceRedrawAll(); + + if(m_pStatusText) + { + m_pStatusText->ParentChangedSize(); + m_pStatusText->Hide(); + } + + //move the site back to where it was. + if( m_pTopLevelSite ) + { + m_pTopLevelSite->_SetPosition(m_CreateWindowPos); + } + + return HXR_OK; +#else + HX_ASSERT( "Not implemented..." == NULL ); +#endif +} + +HX_RESULT CHXExSite::_EnterFullScreenNoNewWindow() +{ +#if 0 + HXxWindow* pWin = GetWindow(); + + HX_ASSERT( pWin && pWin->display && pWin->display); + HX_ASSERT( this == m_pTopLevelSite ); + + if(IsFullScreen() || !pWin) + { + //We are already in full screen + return HXR_FAIL; + } + + //Get the screen size. + XLockDisplay((Display*) pWin->display); + Screen* pScreen = XDefaultScreenOfDisplay((Display*)pWin->display); + UINT16 uHorzRes = WidthOfScreen(pScreen); + UINT16 uVertRes = HeightOfScreen(pScreen); + XUnlockDisplay((Display*)pWin->display); + + //Get ready to resize the presentation.... + if( m_pTopLevelSite ) + { + m_pTopLevelSite->m_bDisableForceRedraw = TRUE; + } + + //Maintain aspect ratio and Scale it. + float fXScale = (float)uHorzRes/(float)(m_size.cx); + float fYScale = (float)uVertRes/(float)(m_size.cy); + float fScale = (fXScaledisplay); + XQueryTree( (Display*)pWin->display, + (Window)pWin->window, + &winRootParent, + &winParent, + &pwinChildren, + &nNumChildren + ); + + //Free unused children list. + XFree( pwinChildren ); + XUnlockDisplay((Display*) pWin->display); + + HX_ASSERT( winParent ); + m_winOldParent = winParent; + + m_bInFullScreen = TRUE; + + //Now resize it... + SetSize(m_size); + + //Redraw the presentation.... + if( m_pTopLevelSite ) + { + m_pTopLevelSite->m_bDisableForceRedraw = FALSE; + } + + _ForceRedrawAll(); + + //Give it focus.... + _SetFocus( (void*)pWin->window ); + + // now eat all the focusouts that came as a result of this reparent... + XEvent event; + XLockDisplay((Display*) pWin->display); + HXBOOL status = XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window, + FocusOut, &event); + XUnlockDisplay((Display*) pWin->display); + while (m_bWindowCreatedByCreate && status) + { + // just discarding these + XLockDisplay((Display*) pWin->display); + status = XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window, + FocusOut, &event); + XUnlockDisplay((Display*) pWin->display); + } + + //Update the status text... + if(m_pStatusText) + { + m_pStatusText->ParentChangedSize(); + m_pStatusText->Show(); + } +#if defined(HELIX_CONFIG_MOBLIN) + if(!m_pAttachWindowCallback) + { + m_pAttachWindowCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)AttachWindowCallback); + m_pAttachWindowCallback->AddRef(); + } + if(!m_pForceRedrawCallback) + { + m_pForceRedrawCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)ForceRedrawCallback); + m_pForceRedrawCallback->AddRef(); + } + + // schedule callback for Attaching Window + if(m_pAttachWindowCallback) + { + m_pAttachWindowCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pAttachWindowCallback, 100)); + } + if(m_pForceRedrawCallback) + { + m_pForceRedrawCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pForceRedrawCallback, 500)); + } + +#endif +#else + HX_ASSERT( "Not implemented..." == NULL ); +#endif + return HXR_OK; +} + +#if defined(HELIX_CONFIG_MOBLIN) +void CHXExSite::AttachWindowCallback(void* pParam) +{ + CHXExSite* pObj = (CHXExSite*)pParam; + if (pObj) + { + pObj->_AttachWindow(); + } +} + + +void CHXExSite::ForceRedrawCallback(void* pParam) +{ + CHXExSite* pObj = (CHXExSite*)pParam; + + if (pObj) + { + UINT32 ulNumOfChildren = pObj->GetNumberOfChildSites(); + if(pObj->m_pTopLevelSite) + { + pObj->m_pTopLevelSite->m_bDisableForceRedraw = FALSE; + } + for ( UINT32 i = 0; i < ulNumOfChildren; ++i ) + { + SPIHXSite spChildSite; + if ( SUCCEEDED( pObj->GetNthChildSite( i, *spChildSite.AsInOutParam() ) ) + && spChildSite.IsValid() ) + { + spChildSite->DamageRegion( NULL ); + spChildSite->ForceRedraw(); + } + + } + } +} + +void CHXExSite::RemovePendingCallback(CHXGenericCallback* pCB) +{ + if (pCB && + pCB->GetPendingCallback() && + m_pScheduler) + { + m_pScheduler->Remove(pCB->GetPendingCallback()); + pCB->CallbackCanceled(); + } +} +#endif + +HX_RESULT CHXExSite::_EnterFullScreenExt(HXxWindow* pWindow, IHXValues* pValues) +{ +#if 0 + m_bReparent = FALSE; + HX_RESULT res = HXR_OK; + UINT32 ulReparent = 0; + + if (pValues) + { + pValues->GetPropertyULONG32("Reparent", ulReparent); + } + + m_bReparent = (HXBOOL)ulReparent; + + if (m_bReparent) + { + res = _EnterFullScreen(pWindow); + } + else + { + res = _EnterFullScreenNoNewWindow(); + } + + CHXBaseSite::FullScreenEntered(res); + return res; +#else + HX_ASSERT( "Not implemented..." == NULL ); + return HXR_OK; /* this makes compiler happy */ +#endif +} + +HX_RESULT CHXExSite::_ExitFullScreenExt() +{ +#if 0 + HX_RESULT res = _ExitFullScreen(); +#if defined(HELIX_CONFIG_MOBLIN) + // schedule callback for attaching window + if(m_pAttachWindowCallback) + { + m_pAttachWindowCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pAttachWindowCallback, 100)); + } + // schedule callback for Force Redraw the window + if(m_pForceRedrawCallback) + { + m_pForceRedrawCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pForceRedrawCallback, 500)); + } +#endif + CHXBaseSite::FullScreenExited(res); + + return res; +#else + HX_ASSERT( "Not implemented..." == NULL ); + return HXR_OK; /* this makes compiler happy */ +#endif + +} + +HX_RESULT CHXExSite::_EventOccurred(HXxEvent* pEvent) +{ + return HXR_OK; +} + +HX_RESULT CHXExSite::_TestFullScreen( void* hTestBitmap, + const char* pszStatusText ) +{ +#ifdef _DEBUG + fprintf( stderr, "Going to test full screen....\n" ); +#endif + return HXR_OK; +} + +void CHXExSite::ProcessEvent(HXxEvent* pEvent) +{ + if(pEvent) + { + //Expose event compression. Combine all outstanding expose events + //into one big region. + if(Expose==pEvent->event) + { + _CollapseExposeEvents((XEvent*)pEvent->param2); + } + } + + //Send the event to each registered UnixSite. + void* pSite = NULL; + void* pWindow = NULL; + POSITION pos = z_mapSiteToWindow.GetStartPosition(); + while( pos ) + { + z_mapSiteToWindow.GetNextAssoc(pos, pSite, pWindow); + CHXExSite* pSiteWindowed = (CHXExSite*)pSite; + CHXExSite* pTopLevel = NULL; + HX_ASSERT(pSiteWindowed); + pSiteWindowed->AddRef(); + pTopLevel = (CHXExSite*)pSiteWindowed->GetTopLevelSite(); + + if(pEvent) + { + //Call back into the basesite's event loop. + pTopLevel->EventOccurred(pEvent); + } + + //XXXgfw As a workaround for the overlay not moving while the + //player is paused, we will check it here and update it if needed. + + //XXXRGG We might be able to use X's ConfigureNotify messages instead + //of doing a refresh every 50 ms. + pTopLevel->_UpdateOverlayIfNeeded(); + + pSiteWindowed->Release(); + } +} + +void CHXExSite::_CollapseExposeEvents(XEvent* xevent) +{ + Display* display = xevent->xany.display; + Window window = xevent->xany.window; + XExposeEvent* expose_event = (XExposeEvent*)xevent; + XEvent new_event; + XExposeEvent* new_expose_event = (XExposeEvent*)&new_event; + ushort x1; + ushort y1; + ushort x2; + ushort y2; + ushort x3; + ushort y3; + + x1 = expose_event->x; + y1 = expose_event->y; + x2 = x1 + expose_event->width; + y2 = y1 + expose_event->height; + XLockDisplay(display); + HXBOOL status = XCheckWindowEvent(display, window, ExposureMask, &new_event); + XUnlockDisplay(display); + while( status) + { + if (new_expose_event->x < x1) + x1 = new_expose_event->x; + + if (new_expose_event->y < y1) + y1 = new_expose_event->y; + + x3 = new_expose_event->x + new_expose_event->width; + if (x3 > x2) + x2 = x3; + + y3 = new_expose_event->y + new_expose_event->height; + if (y3 > y2) + y2 = y3; + XLockDisplay(display); + status = XCheckWindowEvent(display, window, ExposureMask, &new_event); + XUnlockDisplay(display); + + } + + expose_event->x = x1; + expose_event->y = y1; + expose_event->width = x2 - x1; + expose_event->height = y2 - y1; + expose_event->count = new_expose_event->count; +} + + +HXBOOL CHXExSite::_ShouldProcess(HXxEvent* pEvent) +{ + HXBOOL bShouldProcessThisEvent = TRUE; + + + if( !IsSiteVisible() ) + { + switch (pEvent->event) + { + case ButtonPress: + case ButtonRelease: + case Expose: + case FocusIn: + bShouldProcessThisEvent = FALSE; + break; + default: + break; + } + } + + if(m_pWindow && m_pWindow->window!=pEvent->window) + { + bShouldProcessThisEvent = FALSE; + } + return bShouldProcessThisEvent; +} + + +/////////////////////////////////////////////////////// +// +// UnixEventHandler methods... +// +CHXExSite::UnixEventHandler::UnixEventHandler(CHXExSite* pParent) + : m_pParent(pParent), + m_lRefCount(0), + m_cbHandle(0) +{ + HX_ASSERT(m_pParent); + HX_ASSERT(m_pParent->m_pScheduler); + m_cbHandle = m_pParent->m_pScheduler->RelativeEnter((IHXCallback*)this, 30); +} + +CHXExSite::UnixEventHandler::~UnixEventHandler() +{ + CancelCallback(); +} + +void +CHXExSite::UnixEventHandler::CancelCallback() +{ + if( m_cbHandle && m_pParent && m_pParent->m_pScheduler ) + { + UINT32 tempHandle = m_cbHandle; + m_cbHandle = 0; + m_pParent->m_pScheduler->Remove(tempHandle); + } +} + +HX_RESULT CHXExSite::UnixEventHandler::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IHXCallback)) + { + AddRef(); + *ppvObj = (IHXCallback*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +ULONG32 CHXExSite::UnixEventHandler::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +ULONG32 CHXExSite::UnixEventHandler::Release() +{ + HX_ASSERT(m_lRefCount>0); + if( InterlockedDecrement(&m_lRefCount)>0 ) + { + return m_lRefCount; + } + delete this; + return 0; +} + +//IHXCallback methods +HX_RESULT CHXExSite::UnixEventHandler::Func() +{ + XEvent xevent; + static HXxEvent pnevent; + + m_cbHandle = 0; + XLockDisplay(m_pParent->zm_display); + int status = XPending(m_pParent->zm_display); + XUnlockDisplay(m_pParent->zm_display); + while(status) + { + XLockDisplay(m_pParent->zm_display); + XNextEvent(m_pParent->zm_display, &xevent); + XUnlockDisplay(m_pParent->zm_display); + + // package native event in HXxEvent and send to dispatcher + pnevent.event = xevent.type; + pnevent.window = (void *)xevent.xany.window; + pnevent.param1 = xevent.xany.display; + pnevent.param2 = &xevent; + + m_pParent->ProcessEvent(&pnevent); + XLockDisplay(m_pParent->zm_display); + status = XPending(m_pParent->zm_display); + XUnlockDisplay(m_pParent->zm_display); + } + + if (m_pParent && m_pParent->m_pScheduler) + { + m_cbHandle = m_pParent->m_pScheduler->RelativeEnter((IHXCallback*)this, 30); + } + return HXR_OK; +} + +void CHXExSite::_UpdateOverlayIfNeeded() +{ + if( m_pVideoSurface ) + { + if( m_pVideoSurface->m_nBltMode == HX_OVERLAY_BLT ) + { + ULONG32 ulNow = HX_GET_BETTERTICKCOUNT(); + CUnixSurf* pSurf = (CUnixSurf*)m_pVideoSurface; + if( ulNow- pSurf->m_ulLastOverlayUpdateTime > 50 ) + { + SiteMoving(0,0); + } + } + } + LISTPOSITION pos = m_ChildrenInZOrder.GetHeadPosition(); + while(pos) + { + CHXExSite* pSite = (CHXExSite*)m_ChildrenInZOrder.GetNext(pos); + pSite->_UpdateOverlayIfNeeded(); + } +} + + +HXBOOL CHXExSite::_ShouldEnterForceRedraw() +{ + if( !m_bDamaged || !m_pUser || !IsSiteVisible() ) + { + return FALSE; + } + + if(InterlockedIncrement(&m_lBltEntryCount)>1) + { + InterlockedDecrement(&m_lBltEntryCount); + return FALSE; + } + + return TRUE; +} + +void CHXExSite::_ExitForceRedraw() +{ + InterlockedDecrement(&m_lBltEntryCount); +} + Index: helix-libs/clientapps/clutter/exsite.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exsite.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,272 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: unixsite.h,v 1.10.2.3 2008/06/05 14:24:30 lovish Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * Phil Dibowitz (jaymzh) + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _UNIXSITE_H +#define _UNIXSITE_H + +#if defined(USE_XWINDOWS) +#include +#include +#include +#include +#include +#include +#endif + +#include "basesite.h" +#include "hxcbobj.h" +#include "player.h" + +class CHXExSite : public CHXBaseSite +{ +public: + + friend class CExSurf; + friend class CExRootSurf; + + CHXExSite( IUnknown* pContext, + IUnknown* pUnkOuter, + INT32 lInitialZorder, + on_new_frame_cb_t on_new_frame_cb = NULL, + void *context = NULL); + + static void ProcessEvent(HXxEvent* pEvent); + Window CreateXWindow( Window win ); + + void _ForwardUpdateEvent(HXxEvent* pEvent); + + //static member vars. + static Display* zm_display; + void _UpdateOverlayIfNeeded(); + HXBOOL m_bIgnoreFocusOutInFS; + + //We override this. + void CheckColorSettings(); + +protected: + + virtual ~CHXExSite(); + + // + // CHXExSite only methods.... + // + HX_RESULT _OpenXDisplay(char* DiplayString); + static void _CollapseExposeEvents(XEvent* xevent); + HXBOOL _ShouldProcess(HXxEvent* pEvent); + void _DrawArrows(); + void _CreateHorizScrollBar(void); + void _CreateVertScrollBar(void); + HXBOOL _InButton(HXxPoint& pt, int x, int y ); + void _DestroyScrollButtons(); + void _MapScrollButtons(); + void _MapHorzScroll(); + void _MapVertScroll(); + void _UnmapHorzScroll(); + void _UnmapVertScroll(); + void _UnmapScrollButtons(); + void _BuildClipRegion(); + void _ReleaseClippingRegion(); + + // + // Seperate object for our callbacks to keep the events flowing. + // + class UnixEventHandler : public IHXCallback + { + public: + UnixEventHandler(CHXExSite* pParent); + + //IUnknown methods + virtual HX_RESULT QueryInterface(REFIID riid, void** ppvObj); + virtual ULONG32 AddRef(); + virtual ULONG32 Release(); + + //IHXCallback methods + virtual HX_RESULT Func(); + void CancelCallback(); + + private: + virtual ~UnixEventHandler(); + + UnixEventHandler(); + UnixEventHandler(const UnixEventHandler&); + UnixEventHandler& operator=(const UnixEventHandler& it ); + + CHXExSite* m_pParent; + LONG32 m_lRefCount; + CallbackHandle m_cbHandle; + + IUnknown* m_pUnkPlayer; + }; + + + // + // CHXBaseSite inherited methods + // + virtual void _NeedWindowedSite(); + virtual void _AttachWindow(); + virtual void _DetachWindow(); + virtual void* _Create(void* ParentWindow, UINT32 style); + virtual void _Destroy(HXxWindow* pWindow); + virtual void _SetSize(HXxSize size); + virtual void _SetPosition(HXxPoint position); + virtual void _DamageRect(HXxRect rect); + virtual void _DamageRegion(HXxRegion rect); + virtual HXBOOL _ShouldEnterForceRedraw(); + virtual void _ExitForceRedraw(); + virtual void _SendOSUpdateMessage(); + virtual void _ShowSite(HXBOOL bShow); + virtual HXBOOL _AtSystemTime(); + virtual void _GetDeviceCaps( void* hdc, + UINT16& uBitesPerPixel, + UINT16& uHorzRes, + UINT16& uVertRes ); + virtual void _GetWindowRect(HXxRect* destRect); + virtual void _DestroySliders(); + virtual HXBOOL _HandleOSEvents(HXxEvent* pEvent); + virtual HXBOOL _ConvertToHXEvent(HXxEvent* pEvent); + virtual void _GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2); + virtual void _GenerateSetCursorEvent(); + virtual void _TryCreateXSlider(); + virtual void _SetXSliderValues(INT32 range, INT32 pageSize); + virtual void _TryCreateYSlider(); + virtual void _SetYSliderValues(INT32 range, INT32 pageSize); + virtual void _GetSystemSizeOfSliders(INT32* pWidth, INT32* pHeight); + virtual HXBOOL _IsWindowVisible(); + virtual void _ShowXSlider(HXBOOL bShow); + virtual void _MoveXSlider( INT32 left, + INT32 top, + INT32 right, + INT32 bottom, + HXBOOL bRedraw ); + virtual void _ShowYSlider(HXBOOL bShow); + virtual void _MoveYSlider( INT32 left, + INT32 top, + INT32 right, + INT32 bottom, + HXBOOL bRedraw); + virtual HXBOOL _DoesXSliderExist(); + virtual void* _GetContainingWindow(); + virtual void _GetCursorPos(HXxPoint* pPoint); + virtual void _MapPointToOSWindow(HXxPoint* pPt, void** pWindowHandle); + virtual void* _GetWindowWithCursor(); + virtual void _ReInitPrimarySurface(); + virtual HXBOOL _MoveWindow( void* , + INT32 X, + INT32 Y, + INT32 nWidth, + INT32 nHeight, + HXBOOL bRepaint); + virtual HXBOOL _UpdateWindow(void* hWnd); + virtual HXBOOL _ShowWindow(void* hWnd, INT32 nCmdShow); + virtual HXBOOL _SetWindowPos(void* hWnd, + void* hWndInsertAfter, + INT32 X, + INT32 Y, + INT32 cx, + INT32 cy, + INT32 uFlags); + virtual HXBOOL _SetWindowRgn(void* hWnd, HXREGION* hRgn, HXBOOL bRedraw); + virtual void _SetFocus(void* pWindow); + + virtual HX_RESULT _EnterFullScreen(HXxWindow* pWindow = NULL); + virtual HX_RESULT _EventOccurred(HXxEvent* pEvent); + virtual HX_RESULT _ExitFullScreen(); + virtual HX_RESULT _TestFullScreen( void* hTestBitmap, + const char* pszStatusText ); + virtual HX_RESULT _EnterFullScreenExt(HXxWindow* pWindow, IHXValues* pValues); + virtual HX_RESULT _ExitFullScreenExt(); +#if defined(HELIX_CONFIG_MOBLIN) + static void AttachWindowCallback(void *pParam); + static void ForceRedrawCallback(void *pParam); + void RemovePendingCallback(CHXGenericCallback* pCB); + + CHXGenericCallback* m_pAttachWindowCallback; + CHXGenericCallback* m_pForceRedrawCallback; +#endif + HXBOOL m_bReparent; + +private: + + //Protect unintentional copy and default ctors. + CHXExSite(); + CHXExSite( const CHXExSite& ); + CHXExSite& operator=( const CHXExSite& it ); + HX_RESULT _EnterFullScreenNoNewWindow(); + + //member vars. + UnixEventHandler* m_pUnixEventHandler; + static Cursor zm_GrabCursor; + Window m_ScrollHorizButtonL; + Window m_ScrollHorizButtonR; + Window m_ScrollVertButtonT; + Window m_ScrollVertButtonB; + Window m_winFullScreenWindow; + Window m_winOldParent; + HXxPoint m_ptScrollHorizPosL; + HXxPoint m_ptScrollHorizPosR; + HXxPoint m_ptScrollVertPosT; + HXxPoint m_ptScrollVertPosB; + HXxPoint m_ptFullScreenOffset; + HXxSize m_PreFullScreenSize; + HXBOOL m_bScrollingInProgress; + int m_nScrollDir; + HXBOOL m_bLastPointInSite; + HXBOOL m_bDamaged; + // + //Private helpers... + // + + //returns the HX_VK associated with this keysym.... + UINT32 _MapKeySymToHXVK(KeySym tmpSym, UINT32& uFlags); + on_new_frame_cb_t m_on_new_frame_cb; + void *m_context; +}; + +#endif //_UNIXSITE_H Index: helix-libs/clientapps/clutter/exsitsup.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exsitsup.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,455 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifdef _WIN16 +#include +#endif + +#include "hxcom.h" +#include "hxtypes.h" +#include "hxwintyp.h" +#include "hxwin.h" +#include "ihxpckts.h" +#include "hxcomm.h" +#include "fivemmap.h" +#include "hxstring.h" // CHXString +#include "exsite.h" +#include "exsitsup.h" +#include "pckunpck.h" // CreateBufferCCF +#include "ciddefs.h" // CID_RGB32 +#if defined(HELIX_FEATURE_PNG) +#include "pxpngenc.h" // PXPNGEncode::EncodeToPNGBuffer +#endif // HELIX_FEATURE_PNG +#include "print.h" + + +#include "globals.h" +struct _stGlobals*& GetGlobal(); + +/************************************************************************ + * Method: + * Constructor + */ + ExampleSiteSupplier::ExampleSiteSupplier(IUnknown* pUnkPlayer, on_new_frame_cb_t on_new_frame_cb = NULL, void *context = NULL) + : m_lRefCount(0) + , m_pSiteManager(NULL) + , m_pSite(NULL) + , m_pSiteCapture(NULL) + , m_pCaptureBuffer(NULL) + , m_pCCF(NULL) + , m_pUnkPlayer(pUnkPlayer) + , m_on_new_frame_cb(on_new_frame_cb) + , m_context(context) +{ + if (m_pUnkPlayer) + { + m_pUnkPlayer->QueryInterface(IID_IHXSiteManager, + (void**)&m_pSiteManager); + + //printf("pauldebug:m_pUnkplayer->QueryInterface for m_pCCF calling\n"); + m_pUnkPlayer->QueryInterface(IID_IHXCommonClassFactory, + (void**)&m_pCCF); + //printf("pauldebug:m_pUnkplayer->QueryInterface for m_pCCF called\n"); + + m_pUnkPlayer->AddRef(); + } +}; + +/************************************************************************ + * Method: + * Destructor + */ +ExampleSiteSupplier::~ExampleSiteSupplier() +{ + HX_RELEASE(m_pSiteManager); + HX_RELEASE(m_pSite); + HX_RELEASE(m_pSiteCapture); + HX_RELEASE(m_pCaptureBuffer); + HX_RELEASE(m_pCCF); + HX_RELEASE(m_pUnkPlayer); +} + +/************************************************************************ + * Method: + * IUnknown::QueryInterface + */ + STDMETHODIMP +ExampleSiteSupplier::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXSiteSupplier*)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXSiteSupplier)) + { + AddRef(); + *ppvObj = (IHXSiteSupplier*)this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +/************************************************************************ + * Method: + * IUnknown::AddRef + */ + STDMETHODIMP_(ULONG32) +ExampleSiteSupplier::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +/************************************************************************ + * Method: + * IUnknown::Release + */ + STDMETHODIMP_(ULONG32) +ExampleSiteSupplier::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + +/************************************************************************ + * Method: + * IHXSiteSupplier::SitesNeeded + * Purpose: + * Called to inform the site supplier that a site with a particular + * set of characteristics is needed. If the site supplier can + * fulfill the request it should call the site manager and add one + * or more new sites. + * Note that the request for sites is associated with a Request ID + * the client core will inform the site supplier when this requested + * site is no longer needed. + */ +STDMETHODIMP +ExampleSiteSupplier::SitesNeeded +( + UINT32 uRequestID, + IHXValues* pProps + ) +{ + /* + * Don't create a site if the -NULL_RENDER command line option + * was given. - jfarr + */ + if (GetGlobal()->g_bNullRender) + { + return (HXR_OK); + } + + /* + * If there are no properties, then we can't really create a + * site, because we have no idea what type of site is desired! + */ + if (!pProps) + { + return HXR_INVALID_PARAMETER; + } + + HRESULT hres = HXR_OK; + IHXValues* pSiteProps = NULL; + IHXSiteWindowed* pSiteWindowed = NULL; + IHXBuffer* pValue = NULL; + UINT32 style = 0; + IHXSite* pSite = NULL; + +#if 0 + // Just let the RMA client core create a windowed site for us. + hres = m_pCCF->CreateInstance(CLSID_IHXSiteWindowed,(void**)&pSiteWindowed); + if (HXR_OK != hres) + { + goto exit; + } +#else + { + *(void **)&pSiteWindowed = (IUnknown*)(IHXSiteWindowed*)(new CHXExSite(GetGlobal()->pMediaPlatform, NULL, 0, m_on_new_frame_cb, m_context)); + hres = ((IUnknown*)*(void **)&pSiteWindowed)->QueryInterface(IID_IHXSiteWindowed, (void**)&pSiteWindowed); + if (HXR_OK != hres) + { + goto exit; + } + } +#endif + + hres = pSiteWindowed->QueryInterface(IID_IHXSite,(void**)&pSite); + if (HXR_OK != hres) + { + goto exit; + } + + if( !m_pSite ) + { + m_pSite = pSite; + m_pSite->AddRef(); + } + + + hres = pSiteWindowed->QueryInterface(IID_IHXValues,(void**)&pSiteProps); + if (HXR_OK != hres) + { + goto exit; + } + + /* + * We need to figure out what type of site we are supposed to + * to create. We need to "switch" between site user and site + * properties. So look for the well known site user properties + * that are mapped onto sites... + */ + hres = pProps->GetPropertyCString("playto",pValue); + if (HXR_OK == hres) + { + pSiteProps->SetPropertyCString("channel",pValue); + HX_RELEASE(pValue); + } + else + { + hres = pProps->GetPropertyCString("name",pValue); + if (HXR_OK == hres) + { + pSiteProps->SetPropertyCString("LayoutGroup",pValue); + HX_RELEASE(pValue); + } + } + +#ifdef _WINDOWS + style = WS_OVERLAPPED | WS_VISIBLE | WS_CLIPCHILDREN; +#endif + + hres = pSiteWindowed->Create(NULL, style); + if (HXR_OK != hres) + { + goto exit; + } + + /* + * We need to wait until we have set all the properties before + * we add the site. + */ + hres = m_pSiteManager->AddSite(pSite); + if (HXR_OK != hres) + { + goto exit; + } +#ifdef _WINDOWS + { + HXxWindow* pWindow = pSiteWindowed->GetWindow(); + if (pWindow && pWindow->window) ::SetForegroundWindow( (HWND)(pWindow->window) ); + } +#endif + m_CreatedSites.SetAt((void*)uRequestID,pSite); + pSite->AddRef(); + +exit: + + HX_RELEASE(pSiteProps); + HX_RELEASE(pSiteWindowed); + HX_RELEASE(pSite); + + return hres; +} + +/************************************************************************ + * Method: + * IHXSiteSupplier::SitesNotNeeded + * Purpose: + * Called to inform the site supplier that all sites from a previos + * site request are no longer needed. If the site supplier had + * previously created non-persistant sites (like popup windows) + * to fulfill a request for sites it should call the site manager + * and remove those sites. + */ +STDMETHODIMP +ExampleSiteSupplier::SitesNotNeeded(UINT32 uRequestID) +{ + IHXSite* pSite = NULL; + IHXSiteWindowed* pSiteWindowed = NULL; + void* pVoid = NULL; + + if (!m_CreatedSites.Lookup((void*)uRequestID,pVoid)) + { + return HXR_INVALID_PARAMETER; + } + pSite = (IHXSite*)pVoid; + + m_pSiteManager->RemoveSite(pSite); + + // Need to actually do the work on destroying the window + // and all that jazz. + pSite->QueryInterface(IID_IHXSiteWindowed,(void**)&pSiteWindowed); + + pSiteWindowed->Destroy(); + + // ref count = 2 + pSiteWindowed->Release(); + + // ref count = 1; deleted from this object's view! + pSite->Release(); + + m_CreatedSites.RemoveKey((void*)uRequestID); + + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXSiteSupplier::BeginChangeLayout + * Purpose: + * Called to inform the site supplier a layout change has beginning + * it can expect to recieve SitesNeeded() and SitesNotNeeded() calls + * while a layout change is in progress, + */ +STDMETHODIMP +ExampleSiteSupplier::BeginChangeLayout() +{ + return HXR_OK; +} + +/************************************************************************ + * Method: + * IHXSiteSupplier::DoneChangeLayout + * Purpose: + * Called to inform the site supplier the layout change has been + * completed. + */ +STDMETHODIMP +ExampleSiteSupplier::DoneChangeLayout() +{ + return HXR_OK; +} + +HX_RESULT +ExampleSiteSupplier::CaptureImage(CHXString pszFileName, INT32 dWidth, INT32 dHeight) +{ + HX_RESULT res=HXR_FAIL; + + // Get the IHXSiteCapture object from the site + if (m_pSiteCapture == NULL) + { + if (m_pSite && m_pSite->QueryInterface(IID_IHXSiteCapture, (void**)&m_pSiteCapture) == HXR_OK) + { + m_pSiteCapture->AddRef(); + } + } + + // Create the buffer that will receive the image data + if (m_pCaptureBuffer == NULL) + { + CreateBufferCCF(m_pCaptureBuffer, m_pCCF); + if (!m_pCaptureBuffer) + { + return HXR_OUTOFMEMORY; + } + } + + HXBOOL bCanCapture = FALSE; + + // Check if the site is available to capture an image + if (m_pSiteCapture && (res = m_pSiteCapture->CanCapture(bCanCapture)) == HXR_OK && bCanCapture) + { + HX_RESULT res; + HXxSize outputSize; + outputSize.cx = dWidth; + outputSize.cy = dHeight; + m_strFileName = pszFileName; + + // Asynchronous call. CaptureDone() will be called with result. + res = m_pSiteCapture->Capture((IHXSiteCaptureResponse*)this, m_pCaptureBuffer, &outputSize, CID_RGB32); + } + + return res; + +} + +// +// IHXSiteCaptureResponse::CaptureDone +// +// Called when the site has captured the next frame. +// bmiOutputFormat points to image format description which +// is valid until the completion of CaptureDone. +// bmiOutputFormat can be different for every capture. +// pCaptureBuffer holds the image if supplied in +// Capture() method. pCaptureBuffer is automatically +// resized if it has insufficient size to hold the image +// data. +// +// status may be: +// HXR_FAIL -- No capture was done. General Error. All data is invalid. +// HXR_OK -- Capture was done. Both variables are valid. +STDMETHODIMP +ExampleSiteSupplier::CaptureDone(REF(HX_RESULT) status, + REF(HXBitmapInfoHeader) bmiOutputFormat, + REF(IHXBuffer*) pCaptureBuffer) +{ + if (status == HXR_OK) + { +#if defined(HELIX_FEATURE_PNG) + // Convert capture buffer into PNG + IHXBuffer* pConvertedBuffer=NULL; + HX_RESULT res = HXR_OK; + res = PXPNGEncode::EncodeToPNGBuffer(pCaptureBuffer, &bmiOutputFormat, m_pCCF, pConvertedBuffer); + if (res == HXR_OK && !m_strFileName.IsEmpty()) + { + CHXString strTail = m_strFileName.Right(4); + if (strTail.CompareNoCase(".png") != 0) + { + m_strFileName += ".png"; + } + + FILE* fp = fopen(m_strFileName, "wb"); + if (fp) + { + fwrite(pConvertedBuffer->GetBuffer(), 1, pConvertedBuffer->GetSize(), fp); + fclose(fp); + STDOUT("Captured image to PNG file: %s\n", (const char*)m_strFileName); + STDOUT("File size: %ld\n", pConvertedBuffer->GetSize()); + } + HX_RELEASE(pConvertedBuffer); + } +#endif // HELIX_FEATURE_PNG + } + + return status; +} Index: helix-libs/clientapps/clutter/exsitsup.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exsitsup.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,154 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXSITSUP_H_ +#define _EXSITSUP_H_ + +#include "fivemmap.h" +#include "player.h" + +/**************************************************************************** + * + * Class: + * + * ExampleSiteSupplier + * + * Purpose: + * + * Implementation for ragui's IHXSiteSupplier + * + */ +class ExampleSiteSupplier : + public IHXSiteSupplier + , public IHXSiteCaptureResponse +{ +private: + LONG32 m_lRefCount; + IHXSiteManager* m_pSiteManager; + IHXSite* m_pSite; + IHXSiteCapture* m_pSiteCapture; + IHXBuffer* m_pCaptureBuffer; + IHXCommonClassFactory* m_pCCF; + IUnknown* m_pUnkPlayer; + FiveMinuteMap m_CreatedSites; + CHXString m_strFileName; + on_new_frame_cb_t m_on_new_frame_cb; + void * m_context; + + ~ExampleSiteSupplier(); + +public: + ExampleSiteSupplier(IUnknown* pUnkPlayer, on_new_frame_cb_t new_frame_cb = NULL, void *context = NULL); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /* + * IHXSiteSupplier methods + */ + + /************************************************************************ + * Method: + * IHXSiteSupplier::SitesNeeded + * Purpose: + * Called to inform the site supplier that a site with a particular + * set of characteristics is needed. If the site supplier can + * fulfill the request it should call the site manager and add one + * or more new sites. + * Note that the request for sites is associated with a Request ID + * the client core will inform the site supplier when this requested + * site is no longer needed. + */ + STDMETHOD(SitesNeeded) (THIS_ + UINT32 uRequestID, + IHXValues* pSiteProps); + + /************************************************************************ + * Method: + * IHXSiteSupplier::SitesNotNeeded + * Purpose: + * Called to inform the site supplier that all sites from a previos + * site request are no longer needed. If the site supplier had + * previously created non-persistant sites (like popup windows) + * to fulfill a request for sites it should call the site manager + * and remove those sites. + */ + STDMETHOD(SitesNotNeeded) + (THIS_ + UINT32 uRequestID); + + + /************************************************************************ + * Method: + * IHXSiteSupplier::BeginChangeLayout + * Purpose: + * Called to inform the site supplier a layout change has beginning + * it can expect to recieve SitesNeeded() and SitesNotNeeded() calls + * while a layout change is in progress, + */ + STDMETHOD(BeginChangeLayout) (THIS); + + /************************************************************************ + * Method: + * IHXSiteSupplier::DoneChangeLayout + * Purpose: + * Called to inform the site supplier the layout change has been + * completed. + */ + STDMETHOD(DoneChangeLayout) (THIS); + + /* + * IHXSiteCaptureResponse + */ + STDMETHOD(CaptureDone) (THIS_ + REF(HX_RESULT) status, + REF(HXBitmapInfoHeader) bmiOutputFormat, + REF(IHXBuffer*) pImageDataBuffer + ); + + HX_RESULT CaptureImage(CHXString pFileName, INT32 dWidth, INT32 dHeight); + +}; + +#endif // _EXSITSUP_H_ + Index: helix-libs/clientapps/clutter/exstateadvsnk.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exstateadvsnk.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,229 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include + +#include "hxtypes.h" + +#include "hxcom.h" +#include "hxcomm.h" +#include "hxmon.h" +#include "hxcore.h" +#include "hxengin.h" +#include "hxclsnk.h" +#include "hxgroup.h" +#include "hxstrutl.h" +#include "exstateadvsnk.h" +#include "hxstring.h" +#include "hxprefs.h" +#include "excontxt.h" + +#include "print.h" + +#include "globals.h" +#include "player.h" + +struct _stGlobals*& GetGlobal(); //in main.cpp + +#ifdef __TCS__ +extern unsigned long gStreamTime; + +static int iOpened = 0; + + +#if defined(__cplusplus) +extern "C" { +#endif /* defined(__cplusplus) */ + +typedef enum hookBuffering { + eContacting = 0, + eConnecting = 1, + eBuffering = 2, + ePlaying = 3 +}hookBuffering; + +void hookRealAudio_Buffering(hookBuffering connectState, int pct); + +void hookRealAudio_PlayPosition(unsigned long current,unsigned long duration); + +typedef enum hookState { + ePlay = 0, + ePause = 1, + eStop = 2, + eResume = 3, + eComplete // Clip is done playing +}hookState; +void hookRealAudio_State(hookState newState); + + +#if defined(__cplusplus) +} +#endif /* defined(__cplusplus) */ + +#endif // __TCS__ + +void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes); + +ExampleClientStateAdviceSink::ExampleClientStateAdviceSink(IUnknown* pUnknown, LONG32 lClientIndex, on_state_change_cb_t on_state_change_cb, void *context) + : m_lRefCount (0) + , m_lClientIndex (lClientIndex) + , m_pUnknown (NULL) + , m_State (HX_CLIENT_STATE_READY) + , m_state_change_cb(on_state_change_cb) + , m_context(context) +{ + if (pUnknown) + { + m_pUnknown = pUnknown; + m_pUnknown->AddRef(); + + IHXPlayer* pPlayer; + IHXClientStateAdviseSinkControl *pStateControl; + if(HXR_OK == m_pUnknown->QueryInterface(IID_IHXPlayer, + (void**)&pPlayer)) + { + m_pPlayer = pPlayer; + + + } + + if (HXR_OK == m_pUnknown->QueryInterface(IID_IHXClientStateAdviseSinkControl, (void **)&pStateControl)) + { + pStateControl->AddClientStateAdviseSink(this); + } + } + +#ifdef __TCS__ + bEnableAdviceSink = TRUE; + iOpened = 0; +#endif +} + +ExampleClientStateAdviceSink::~ExampleClientStateAdviceSink(void) +{ + + if (m_pPlayer) + { + m_pPlayer->Release(); + m_pPlayer = NULL; + } + if (m_pUnknown) + { + m_pUnknown->Release(); + m_pUnknown = NULL; + } +} + + +// *** IUnknown methods *** + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::QueryInterface +// Purpose: +// Implement this to export the interfaces supported by your +// object. +// +STDMETHODIMP ExampleClientStateAdviceSink::QueryInterface(REFIID riid, void** ppvObj) +{ + if (IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppvObj = (IUnknown*)(IHXClientStateAdviseSink *)this; + return HXR_OK; + } + else if (IsEqualIID(riid, IID_IHXClientStateAdviseSink)) + { + AddRef(); + *ppvObj = (IHXClientStateAdviseSink*)this; + return HXR_OK; + } + + *ppvObj = NULL; + return HXR_NOINTERFACE; +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::AddRef +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientStateAdviceSink::AddRef() +{ + return InterlockedIncrement(&m_lRefCount); +} + +///////////////////////////////////////////////////////////////////////// +// Method: +// IUnknown::Release +// Purpose: +// Everyone usually implements this the same... feel free to use +// this implementation. +// +STDMETHODIMP_(ULONG32) ExampleClientStateAdviceSink::Release() +{ + if (InterlockedDecrement(&m_lRefCount) > 0) + { + return m_lRefCount; + } + + delete this; + return 0; +} + + +/************************************************************************ + * Method: + * IHXClientStateAdviseSink::OnStateChange + * Purpose: + * Called to advise the client state has changed state + */ +STDMETHODIMP ExampleClientStateAdviceSink::OnStateChange(UINT16 uOldState, UINT16 uNewState) +{ + if (m_state_change_cb) + m_state_change_cb(uOldState, uNewState, m_context); + + m_State = uNewState; + return HXR_OK; +} + +EHXClientState ExampleClientStateAdviceSink::GetState() +{ + return m_State; +} + + Index: helix-libs/clientapps/clutter/exstateadvsnk.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/exstateadvsnk.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,108 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _EXAMPLE_CLIENT_STATE_ADVISE_SNK_H_ +#define _EXAMPLE_CLIENT_STATE_ADVISE_SNK_H_ + +#include "player.h" + +struct IHXClientStateAdviseSink; +struct IHXGroupSink; +struct IUnknown; +struct IHXRegistry; +struct IHXScheduler; +struct IHXCallback; +struct IHXPlayer; +struct IHXGroup; + +class ExampleClientStateAdviceSink : public IHXClientStateAdviseSink +{ + private: + LONG32 m_lRefCount; + LONG32 m_lClientIndex; + + IUnknown* m_pUnknown; + + UINT32 m_ulStartTime; + UINT32 m_ulStopTime; + + UINT32 m_lCurrentBandwidth; + UINT32 m_lAverageBandwidth; + HXBOOL m_bOnStop; + + HXBOOL m_bWaitForTrackStart; + + on_state_change_cb_t m_state_change_cb; + void *m_context; + EHXClientState m_State; + + // IHXCallback + IHXPlayer* m_pPlayer; + ULONG32 m_hCallback; + ~ExampleClientStateAdviceSink(); + + + public: + + ExampleClientStateAdviceSink(IUnknown* /*IN*/ pUnknown, LONG32 /*IN*/ lClientIndex, on_state_change_cb_t on_state_change_cb = NULL, void *context = NULL); + + /* + * IUnknown methods + */ + STDMETHOD(QueryInterface) (THIS_ + REFIID riid, + void** ppvObj); + + STDMETHOD_(ULONG32,AddRef) (THIS); + + STDMETHOD_(ULONG32,Release) (THIS); + + /*********************************************************************** + * Method: + * IHXClientStateAdviseSink::OnStateChange + * Purpose: + * Called by client engine to inform the client that the state has changed. + * States are defined in the enum EHXClientState, defined in this file. + * + */ + STDMETHOD(OnStateChange) (THIS_ + UINT16 uOldState, + UINT16 uNewState + ) ; + + EHXClientState GetState(); +}; + +#endif /* _EXAMPLECLSNK_ */ Index: helix-libs/clientapps/clutter/fivemmap.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/fivemmap.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,175 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include +#include "hxtypes.h" +#include "fivemmap.h" + +void* FiveMinuteMap::GetFirstValue() +{ + m_nCursor = 0; + + if (m_nMapSize) + { + return m_pValueArray[m_nCursor]; + } + else + { + return NULL; + } +} + +void* FiveMinuteMap::GetNextValue() +{ + m_nCursor++; + + if (m_nCursor < m_nMapSize) + { + return m_pValueArray[m_nCursor]; + } + else + { + return NULL; + } +} + +HXBOOL FiveMinuteMap::Lookup(void* Key, void*& Value) const +{ + HXBOOL bFound = FALSE; + int nIndex = 0; + + // If Key is alrady in the list, replace value + for (; nIndex < m_nMapSize; nIndex++) + { + if (m_pKeyArray[nIndex] == Key) + { + Value = m_pValueArray[nIndex]; + bFound = TRUE; + goto exit; + } + } + +exit: + return bFound; +} + +void FiveMinuteMap::RemoveKey(void* Key) +{ + HXBOOL bFound = FALSE; + int nIndex = 0; + + // If Key is alrady in the list, replace value + for (; nIndex < m_nMapSize; nIndex++) + { + if (m_pKeyArray[nIndex] == Key) + { + if (nIndex < (m_nMapSize-1)) + { + memmove(&(m_pKeyArray[nIndex]),&(m_pKeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); + memmove(&(m_pValueArray[nIndex]),&(m_pValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); + } + m_nMapSize--; + goto exit; + } + } + +exit: + (NULL); // We're done! +} + +void FiveMinuteMap::RemoveValue(void* Value) +{ + HXBOOL bFound = FALSE; + int nIndex = 0; + + // If Value is alrady in the list, replace value + for (; nIndex < m_nMapSize; nIndex++) + { + if (m_pValueArray[nIndex] == Value) + { + if (nIndex < (m_nMapSize-1)) + { + memmove(&(m_pKeyArray[nIndex]),&(m_pKeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); + memmove(&(m_pValueArray[nIndex]),&(m_pValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); + } + m_nMapSize--; + goto exit; + } + } + +exit: + (NULL); // We're done! +} + + +void FiveMinuteMap::SetAt(void* Key, void* Value) +{ + int nIndex = 0; + + // If Key is alrady in the list, replace value + for (; nIndex < m_nMapSize; nIndex++) + { + if (m_pKeyArray[nIndex] == Key) + { + m_pValueArray[nIndex] = Value; + goto exit; + } + } + + // If we have room, add it to the end! + if (m_nAllocSize == m_nMapSize) + { + m_nAllocSize += AllocationSize; + void** pNewKeys = new void*[m_nAllocSize]; + void** pNewValues = new void*[m_nAllocSize]; + + memcpy(pNewKeys,m_pKeyArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */ + memcpy(pNewValues,m_pValueArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */ + + delete [] m_pKeyArray; + delete [] m_pValueArray; + + m_pKeyArray = pNewKeys; + m_pValueArray = pNewValues; + } + + m_pKeyArray[m_nMapSize] = Key; + m_pValueArray[m_nMapSize] = Value; + m_nMapSize++; + +exit: + (NULL); // We're done! +} + Index: helix-libs/clientapps/clutter/fivemmap.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/fivemmap.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,79 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _FIVEMMAP_H_ +#define _FIVEMMAP_H_ + +#ifndef _HXTYPES_H_ +#error FiveMinuteMap assumes pntypes.h. +#endif + +class FiveMinuteMap +{ + const int AllocationSize; + + void** m_pKeyArray; + void** m_pValueArray; + int m_nMapSize; + int m_nAllocSize; + int m_nCursor; +public: + FiveMinuteMap() + : m_pKeyArray(NULL) + , m_pValueArray(NULL) + , m_nMapSize(0) + , m_nAllocSize(0) + , m_nCursor(0) + , AllocationSize(10) + {}; + + ~FiveMinuteMap() + { + delete [] m_pKeyArray; + delete [] m_pValueArray; + }; + + int GetCount() {return m_nMapSize;} + + void* GetFirstValue(); + void* GetNextValue(); + + HXBOOL Lookup(void* Key, void*& Value) const; + void RemoveKey(void* Key); + void RemoveValue(void* Value); + void SetAt(void* Key, void* Value); +}; + +#endif /* _FIVEMMAP_H_ */ Index: helix-libs/clientapps/clutter/globals.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/globals.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,150 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +/**************************************************************************** + * + * Test Client: + * + * + * This is an test client running on Windows, Mac, and Unix without a GUI. + * + */ + +#ifndef _SPLAY_GLOBALS_H +#define _SPLAY_GLOBALS_H + +#include "dllacces.h" +#include "dllpath.h" +#include "hxengin.h" +#include "hxplayvelocity.h" +#include "hxcore.h" +#include "ihxmedpltfm.h" +#include "excontxt.h" +#include "preflist.h" + +#define HX_COMMAND_BUFFER_SIZE 256 +#define HX_MAX_NUM_MULTI_SEEKS 10 +struct _stGlobals +{ + _stGlobals() + : g_pDLLAccess(NULL), + g_nPlayers(0), + m_fpHXMediaPlatformOpen(NULL), + m_fpHXCreateMediaPlatform(NULL), + m_fpHXMediaPlatformClose(NULL), + m_fpCreateEngine(NULL), + m_fpCloseEngine(NULL), + m_fpSetDLLAccessPath(NULL), + bEnableAdviceSink(FALSE), + bEnableVerboseMode(FALSE), + g_bEnableSlowStart(TRUE), + g_bOnBeginOccurred(FALSE), + g_pszUsername( NULL), + g_pszPassword(NULL), + g_pszGUIDFile(NULL), + g_pszGUIDList(NULL), + g_Error(HXR_OK), + g_ulNumSecondsPlayed(0), + pMediaPlatform(NULL), + g_pIHXKicker(NULL), + bUseLegacyAPIs(FALSE), + pEngine(NULL), + g_pQuickSeek(NULL), + g_bNullRender(FALSE), + g_bUserStop(FALSE), + g_bInitVelocity(FALSE), + g_bABD(FALSE), + g_pVelocityCaps(NULL), + g_ulNumMultiSeeks(0), + g_ulMultiSeekIndex(0), + g_bMultiSeek(FALSE), + g_uThreadIDForKicker(-1) + { + memset(g_szCommandBuffer, 0, HX_COMMAND_BUFFER_SIZE); + memset(g_szPriorCommandBuffer, 0, HX_COMMAND_BUFFER_SIZE); + memset(g_Players, 0, sizeof(g_Players)); + memset(g_pszURLs, 0, sizeof(g_pszURLs)); + memset(g_pClientContexts, 0, sizeof(g_pClientContexts)); + } + + #define MAX_NUM_PLAYERS 256 + IHXPlayer* g_Players[MAX_NUM_PLAYERS]; + char *g_pszURLs[MAX_NUM_PLAYERS]; + ExampleClientContext *g_pClientContexts[MAX_NUM_PLAYERS]; + int g_nPlayers; + DLLAccessPath g_statclnt; + DLLAccess* g_pDLLAccess; + CHXPrefList g_prefList; + + FPHXMEDIAPLATFORMOPEN m_fpHXMediaPlatformOpen; + FPHXCREATEMEDIAPLATFORM m_fpHXCreateMediaPlatform; + FPHXMEDIAPLATFORMCLOSE m_fpHXMediaPlatformClose; + + FPRMCREATEENGINE m_fpCreateEngine; + FPRMCLOSEENGINE m_fpCloseEngine; + FPRMSETDLLACCESSPATH m_fpSetDLLAccessPath; + + HXBOOL bEnableAdviceSink; + HXBOOL bEnableVerboseMode; + HXBOOL g_bEnableSlowStart; + HXBOOL g_bOnBeginOccurred; + char* g_pszUsername; + char* g_pszPassword; + char* g_pszGUIDFile; + char* g_pszGUIDList; + HX_RESULT g_Error; + UINT32 g_ulNumSecondsPlayed; + IHXMediaPlatform* pMediaPlatform; + IHXMediaPlatformKicker* g_pIHXKicker; + UINT32 g_uThreadIDForKicker; + pthread_t g_pThreadKickmanId; + HXBOOL bUseLegacyAPIs; + IHXClientEngine* pEngine; + IHXQuickSeek* g_pQuickSeek; + HXBOOL g_bNullRender; + HXBOOL g_bUserStop; + HXBOOL g_bInitVelocity; + HXBOOL g_bABD; + IHXPlaybackVelocityCaps* g_pVelocityCaps; + HXBOOL g_bMultiSeek; + UINT32 g_ulMultiSeekTime[HX_MAX_NUM_MULTI_SEEKS]; + UINT32 g_ulNumMultiSeeks; + UINT32 g_ulMultiSeekIndex; + char g_szCommandBuffer[HX_COMMAND_BUFFER_SIZE]; + char g_szPriorCommandBuffer[HX_COMMAND_BUFFER_SIZE]; +}; + + +#endif // _SPLAY_GLOBALS_H Index: helix-libs/clientapps/clutter/iids.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/iids.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,50 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +// define all guids here once... +#define INITGUID +#define NCIHACK +#include "hxtypes.h" +#include "hxcom.h" +#include "hxiids.h" +#include "hxpiids.h" +#if defined _WINDOWS +#if defined (HELIX_FEATURE_DIRECT_SOUND) +#include "dsound.h" +#endif /* HELIX_FEATURE_DIRECT_SOUND */ +#if defined (HELIX_FEATURE_VIDEO) && !defined(_WINCE) +#include "ddraw.h" +#endif /* HELIX_FEATURE_VIDEO */ +#endif Index: helix-libs/clientapps/clutter/linux2.pcf =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/linux2.pcf 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,42 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: RCSL 1.0/RPSL 1.0 +# +# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. +# +# The contents of this file, and the files included with this file, are +# subject to the current version of the RealNetworks Public Source License +# Version 1.0 (the "RPSL") available at +# http://www.helixcommunity.org/content/rpsl unless you have licensed +# the file under the RealNetworks Community Source License Version 1.0 +# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, +# in which case the RCSL will apply. You may also obtain the license terms +# directly from RealNetworks. You may not use this file except in +# compliance with the RPSL or, if you have a valid RCSL with RealNetworks +# applicable to this file, the RCSL. Please see the applicable RPSL or +# RCSL for the rights, obligations and limitations governing use of the +# contents of the file. +# +# This file is part of the Helix DNA Technology. RealNetworks is the +# developer of the Original Code and owns the copyrights in the portions +# it created. +# +# This file, and the files included with this file, is distributed and made +# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, +# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS +# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. +# +# Technology Compatibility Kit Test Suite(s) Location: +# http://www.helixcommunity.org/content/tck +# +# Contributor(s): +# +# ***** END LICENSE BLOCK ***** +# + +project.AddSystemLibraries("dl", "m", "pthread") + +if (project.IsDefined("HELIX_FEATURE_VIDEO") and + project.IsDefined("USE_XWINDOWS")): + project.AddSystemLibraries("X11") Index: helix-libs/clientapps/clutter/player.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/player.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,1057 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +/**************************************************************************** + * + * Test Client: + * + * + * This is an test client running on Windows, Mac, and Unix without a GUI. + * + */ +#include "hxtypes.h" + +#include + +#include "hlxclib/time.h" +#include "ihxmedpltfm.h" +#include "hxwintyp.h" +#include "hxcom.h" +#include "ihxpckts.h" +#include "hxcomm.h" +#include "hxmon.h" +#include "hxfiles.h" +#include "hxengin.h" +#include "hxcore.h" +#include "hxclsnk.h" +#include "hxgroup.h" +#include "hxerror.h" +#include "hxauth.h" +#include "hxwin.h" +#include "hxprefs.h" +#include "hxtbuf.h" +#include "fivemmap.h" +#include "dllacces.h" +#include "hxausvc.h" +#include "hxstrutl.h" +#include "hxgroup.h" +#include "hxwin.h" +#include "hxtick.h" +#include "hxbuffer.h" +#include "hxplayvelocity.h" +#include "pckunpck.h" // For CreateAndSetBufferCCF() +#include "hxvctrl.h" +#include "hxbsrc.h" +#include "excallback.h" +#include "pthread.h" + +#if defined(HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION) +#include "hxpfs.h" +#endif // HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION. + +#if defined(HELIX_FEATURE_PREFERENCES) +#include "preflist.h" +#endif /* #if defined(HELIX_FEATURE_PREFERENCES) */ +#include "exadvsnk.h" +#include "exerror.h" +#include "exsitsup.h" +#include "exaumgr.h" +#if defined(_WIN32) +#include "exabd.h" +#endif +#include "excontxt.h" +#include "print.h" +#if defined(USE_XWINDOWS) +#include +#endif +#if defined (_UNIX) +#include +#include +#include +#include +#include +#endif +#if defined(_WINDOWS) +#include +#endif + +#ifdef __TCS__ +#include +#if defined(__cplusplus) +extern "C" { +#endif /* defined(__cplusplus) */ + extern unsigned long tmosTimSleep(unsigned long ticks); + unsigned long gForcePlayerToStop = 0; +#if defined(__cplusplus) +} +#endif /* defined(__cplusplus) */ +#endif + +#if defined (_MACINTOSH) || defined (_MAC_UNIX) +bool gMacPlayerIsDone = false; +#endif + + +#if defined _VXWORKS +#include "sys/times.h" +#include "string.h" +#include "hxtime.h" +#endif + +#if defined(_MACINTOSH) +#ifndef _MAC_MACHO +#include +#include +#endif +#endif + +#include "dllpath.h" + +#ifdef _SYMBIAN +#include +#include "platform/symbian/symbian_event_hndlr.h" +#endif + +ENABLE_DLLACCESS_PATHS(g_SPlayAccessPath); + +// typedef for SetDLLAccessPath + + +#include "thrdutil.h" + +#if defined(_AIX) +#include +#endif + +#if defined _DEBUG || defined DEBUG +#include "debug.h" +#endif + +#ifndef MAX_PATH +#define MAX_PATH 256 +#endif //!MAX_PATH + +#if defined(HELIX_CONFIG_NOSTATICS) +# include "globals/hxglobals.h" +#endif + +#define MAX_NUM_URLS 10 + +#include "globals.h" //for global struct. + +#include "player.h" + +#if defined(_WINDOWS) && defined(_STATICALLY_LINKED) +HINSTANCE g_hInstance = NULL; +#endif + +struct _stGlobals*& GetGlobal() +{ +#if defined(HELIX_CONFIG_NOSTATICS) + static const struct _stGlobals* const _g_pstGlobals = NULL; + struct _stGlobals*& g_pstGlobals = (struct _stGlobals*&)HXGlobalPtr::Get(&_g_pstGlobals); +#else + static struct _stGlobals* g_pstGlobals = NULL; +#endif + if( g_pstGlobals == NULL ) + { + g_pstGlobals = new struct _stGlobals(); + } + return g_pstGlobals; + +} + + +// Constants +const int DEFAULT_TIME_DELTA = 2000; +const int DEFAULT_STOP_TIME = -1; +const int SLEEP_TIME = 5; +const int GUID_LEN = 64; + +// Function prototypes +void PrintUsage(const char* pszAppName); +HXBOOL AllPlayersDone(int nNumPlayers, IHXPlayer** ppPlayers); +void StopAllPlayers(int nNumPlayers, IHXPlayer** ppPlayers); +HXBOOL ReadGUIDFile(); +char* GetAppName(char* pszArgv0); + +#ifdef __TCS__ +#if defined(__cplusplus) +extern "C" { +#endif /* defined(__cplusplus) */ + + extern void _alloc_stats(int verbose); +#if defined(__cplusplus) +} +#endif /* defined(__cplusplus) */ + +static IHXPlayer** g_Players; +static int g_nPlayers = 0; +static long evtCount = 0; +static long evtFullCount = 0; +#endif + + + +#if defined(HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION) +HX_RESULT +DumpPFdata(IHXPresentationFeatureManager* pPFMgr, + const char* pszPFName) +{ + HX_RESULT hxr = HXR_OK; + + IHXBuffer* pFeatureCurrentSetting = NULL; + IHXValues* pFeatureOptions = NULL; + + if (!pPFMgr || !pszPFName) + { + hxr = HXR_INVALID_PARAMETER; + } + else + { + // List all the options for this PF: + HX_RESULT hxr = pPFMgr->GetPresentationFeature( + pszPFName, + pFeatureCurrentSetting, + pFeatureOptions); + + if (FAILED(hxr)) + { + // PF doesn't exist! + STDOUT("\t%s - No such presentation feature\n\n", pszPFName); + } + else + { + // Now, go through pFeatureOptions and display + // them and their "is-selectable"-flag values: + const char* pszPFOptionName = NULL; + const char* pszPFCurSetting = pFeatureCurrentSetting? + (const char*)pFeatureCurrentSetting->GetBuffer() : NULL; + UINT32 bPFOptionIsSelectableFlag = FALSE; + IHXBuffer* pPFOptionIsSelectableFlag = NULL; + + HX_ASSERT(pszPFCurSetting); + STDOUT("\t%s\t(Current setting == \"%s\")\n", pszPFName, pszPFCurSetting? + pszPFCurSetting : ""); + + if (!pFeatureOptions) // NULL is OK; that means freeform (open-ended): + { + STDOUT("\t\t(%s's options are freeform, i.e., open-ended)\n", + pszPFName); + } + else // List all the options and their flags: + { + if (HXR_OK == pFeatureOptions->GetFirstPropertyCString(pszPFOptionName, + pPFOptionIsSelectableFlag) && *pszPFOptionName) + { + do + { + const UCHAR* pIsSelFlag = pPFOptionIsSelectableFlag->GetBuffer(); + if (pIsSelFlag && *pIsSelFlag) + { + // Anything but '0' (zero) is treated as '1' (is selectable): + bPFOptionIsSelectableFlag = (HXBOOL)('0' != *pIsSelFlag && + '\0' == *(pIsSelFlag+1)); + } + else + { + // Set the error, but we'll go ahead and treat it as '0': + hxr = HXR_INVALID_PARAMETER; + bPFOptionIsSelectableFlag = FALSE; + } + + STDOUT("\t\t%s\t\tIs selectable: %s\n", + pszPFOptionName, bPFOptionIsSelectableFlag? "yes":"no"); + // Release it to get the next PF: + HX_RELEASE(pPFOptionIsSelectableFlag); + } while (HXR_OK == pFeatureOptions->GetNextPropertyCString( + pszPFOptionName, pPFOptionIsSelectableFlag)); + } + } + + HX_RELEASE(pPFOptionIsSelectableFlag); + } + } + + HX_RELEASE(pFeatureCurrentSetting); + HX_RELEASE(pFeatureOptions); + + return hxr; +} +#endif // HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION. + + +char* RemoveWrappingQuotes(char* str) +{ + int len = strlen(str); + if (len > 0) + { + if (str[len-1] == '"') str[--len] = 0; + if (str[0] == '"') { int i = 0; do { str[i++] = str[i+1]; } while(--len); } + } + return str; +} + +void *kickman(void *dummy) +{ + while(1) { + UINT32 sleepTime = 0; + IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker; + if( pKicker ) + { + pKicker->Kick(GetGlobal()->g_uThreadIDForKicker, &sleepTime); + } + usleep(sleepTime); + } +} + +PLAYER_API int init_main( ) +{ +#if defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC) + setvbuf(stdout, NULL, _IONBF, 0); +#endif /* defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC) */ + + FPHXMEDIAPLATFORMOPEN fpHXMediaPlatformOpen = NULL; + FPHXCREATEMEDIAPLATFORM fpHXCreateMediaPlatform = NULL; + FPHXMEDIAPLATFORMCLOSE fpHXMediaPlatformClose = NULL; + + FPRMCREATEENGINE fpCreateEngine = NULL; + FPRMCLOSEENGINE fpCloseEngine = NULL; + FPRMSETDLLACCESSPATH fpSetDll = NULL; + + HX_RESULT theErr = HXR_OK; + ExampleClientContext** ppExContexts = NULL; +#if defined(HELIX_FEATURE_AUTO_BANDWIDTH_DETECTION) && defined(_WIN32) + ExampleABD* pABD = NULL; +#endif + IHXPlayer** ppPlayers = NULL; + IHXQuickSeek* ppQuickSeek = NULL; + IHXErrorSink* pErrorSink = NULL; + IHXErrorSinkControl* pErrorSinkControl = NULL; + UINT32 ulABDResult = 0; + UINT32 ulProbPktSize = 0; + UINT32 ulProbPktNum = 0; +#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) + INT32 lVelocity = 100; + INT32 lKeyFrameMode = 0; + INT32 lAutoSwitch = 0; +#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */ + CHXString* pABDServer = NULL; + char* pszURL[MAX_NUM_URLS]; + char* pszURLOrig[MAX_NUM_URLS]; + UINT32 ulNumURLsFound = 0; + int nNumPlayers = 1; + int nNumPlayRepeats = 1; + int nTimeDelta = DEFAULT_TIME_DELTA; + int nStopTime = DEFAULT_STOP_TIME; + bool bStopTime = true; + int i = 0; + char* pszGUIDList = NULL; +#ifdef _MACINTOSH + char dllhome[MAX_PATH] = {'\0'}; /* Flawfinder: ignore */ +#elif defined(_SYMBIAN) + char dllhome[MAX_PATH] = "c:"; /* Flawfinder: ignore */ +#else + char dllhome[MAX_PATH] = {'.','\0'}; /* Flawfinder: ignore */ +#endif + DLLAccess* pDLLAccess = NULL; + char staticLibPath[MAX_PATH] = {0}; /* Flawfinder: ignore */ +#ifdef _WINDOWS + HINSTANCE hDll = NULL; +#endif + bool bStopping = false; + int nPlay = 0; + + // NULL out the URL arrays + memset(pszURL, 0, MAX_NUM_URLS * sizeof(char*)); + memset(pszURLOrig, 0, MAX_NUM_URLS * sizeof(char*)); + + + //See if the user has set their HELIX_LIBS env var. This is overridden by the + //-l option. + const char* pszHelixLibs = getenv("HELIX_LIBS"); + if( pszHelixLibs ) + SafeStrCpy( dllhome, pszHelixLibs, MAX_PATH); + + + + GetGlobal()->bEnableAdviceSink = TRUE; + GetGlobal()->g_prefList.Add("UseOverlay", "0"); + + SafeSprintf(staticLibPath, MAX_PATH, "%s/%s", dllhome, "hxmedpltfm.so"); + + if (dllhome) + { + GetDLLAccessPath()->SetPath(DLLTYPE_COMMON, dllhome); + GetDLLAccessPath()->SetPath(DLLTYPE_PLUGIN, dllhome); + GetDLLAccessPath()->SetPath(DLLTYPE_CODEC, dllhome); + } + + // initialize the globals + GetGlobal()->m_fpCreateEngine = NULL; + GetGlobal()->m_fpCloseEngine = NULL; + GetGlobal()->g_nPlayers = 0; + + // prepare/load the HXCore module + pDLLAccess = new DLLAccess(); + + STDOUT("Simpleplayer is looking for the client core at %s\n", staticLibPath ); + + if (DLLAccess::DLL_OK != pDLLAccess->open(staticLibPath)) + { + const char* pErrorString = NULL; + pErrorString = pDLLAccess->getErrorString(); + STDERR("splayer: %s\n\n", pErrorString); +#ifndef _STATICALLY_LINKED +#ifndef _MACINTOSH + //Make sure the user has told us where to find the DLLs at. Either + //with the -l option or with the HELIX_LIBS env var. + STDERR("You must tell the player where to find the client core and\n"); + STDERR("all of its supporting DLLs and codecs. Please use the -l\n"); + STDERR("option or set your HELIX_LIBS env variable to point the player.\n"); + STDERR("to where you have all of the DLLs installed.\n\n" ); + //PrintUsage(argv[0]); +#endif +#endif + goto cleanup; + } + + GetGlobal()->m_fpHXMediaPlatformOpen = (FPHXMEDIAPLATFORMOPEN) pDLLAccess->getSymbol("HXMediaPlatformOpen"); + GetGlobal()->m_fpHXCreateMediaPlatform = (FPHXCREATEMEDIAPLATFORM) pDLLAccess->getSymbol("HXCreateMediaPlatform"); + GetGlobal()->m_fpHXMediaPlatformClose = (FPHXMEDIAPLATFORMCLOSE) pDLLAccess->getSymbol("HXMediaPlatformClose"); + + GetGlobal()->m_fpCreateEngine = (FPRMCREATEENGINE) pDLLAccess->getSymbol("CreateEngine"); + GetGlobal()->m_fpCloseEngine = (FPRMCLOSEENGINE) pDLLAccess->getSymbol("CloseEngine"); + GetGlobal()->m_fpSetDLLAccessPath = (FPRMSETDLLACCESSPATH) pDLLAccess->getSymbol("SetDLLAccessPath"); + + if (GetGlobal()->m_fpHXMediaPlatformOpen == NULL || + GetGlobal()->m_fpHXCreateMediaPlatform == NULL || + GetGlobal()->m_fpHXMediaPlatformClose == NULL || + GetGlobal()->m_fpCreateEngine == NULL || + GetGlobal()->m_fpCloseEngine == NULL || + GetGlobal()->m_fpSetDLLAccessPath == NULL ) + { + theErr = HXR_FAILED; + goto cleanup; + } + +#if defined(USE_XWINDOWS) && defined(HELIX_FEATURE_VIDEO) + XInitThreads(); +#endif + + { + fpHXMediaPlatformOpen = GetGlobal()->m_fpHXMediaPlatformOpen; + fpHXCreateMediaPlatform = GetGlobal()->m_fpHXCreateMediaPlatform; + fpHXMediaPlatformClose = GetGlobal()->m_fpHXMediaPlatformClose; + + if (HXR_OK != fpHXMediaPlatformOpen()) + { + theErr = HXR_FAILED; + goto cleanup; + } + + if (HXR_OK != fpHXCreateMediaPlatform((IHXMediaPlatform**)&GetGlobal()->pMediaPlatform)) + { + theErr = HXR_FAILED; + goto cleanup; + } + + IHXMediaPlatform* pMediaPlatform = GetGlobal()->pMediaPlatform; + + + if (HXR_OK != pMediaPlatform->AddPluginPath("HelixSimplePlayer", dllhome)) + { + theErr = HXR_FAILED; + goto cleanup; + } + + if (HXR_OK != pMediaPlatform->Init(NULL)) + { + theErr = HXR_FAILED; + goto cleanup; + } + + IHXCommonClassFactory* pCCF = NULL; + if (HXR_OK != pMediaPlatform->QueryInterface(IID_IHXCommonClassFactory, + (void**)&pCCF)) + { + theErr = HXR_FAILED; + goto cleanup; + } + + if (HXR_OK != pCCF->CreateInstance(CLSID_IHXClientEngine, (void**)&GetGlobal()->pEngine)) + { + HX_RELEASE(pCCF); + theErr = HXR_FAILED; + goto cleanup; + } + + HX_RELEASE(pCCF); + + IHXMediaPlatformKicker* pKicker = NULL; + pMediaPlatform->QueryInterface(IID_IHXMediaPlatformKicker, (void**)&pKicker); + HX_ASSERT(pKicker); + GetGlobal()->g_pIHXKicker = pKicker; + GetGlobal()->g_uThreadIDForKicker = HXGetCurrentThreadID(); + + pthread_t thread_id; + pthread_create(&thread_id, NULL, kickman, NULL); + GetGlobal()->g_pThreadKickmanId = thread_id; + } + + + + { + + +#if defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC) + SetConsoleCtrlHandler((PHANDLER_ROUTINE)HandlerRoutine, + TRUE); +#endif + + } + + return HXR_OK; + + cleanup: + deinit_main(); + return HXR_FAIL; +} + +/* Get the least index to available entry in Getglobal()->gPlayers */ +static int get_index() +{ + int i; + /* an simple implementation */ + for (i = 0; i < MAX_NUM_PLAYERS; i++) + { + if (GetGlobal()->g_Players[i] == NULL) + return i; + } + + return -1; +} + +PLAYER_API unsigned int get_curr_playtime(void *pPlayerHandle) +{ + unsigned int time = 0; + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + if (pPlayer) + time = pPlayer->GetCurrentPlayTime(); + return time; +} + +PLAYER_API int get_player(void **ppPlayerHandle, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, on_state_change_cb_t on_state_change_cb, on_new_frame_cb_t on_new_frame_cb, void *context) +{ + int index = get_index(); + IHXPlayer **ppPlayer = (IHXPlayer **)ppPlayerHandle; + ExampleClientContext* pExContext = NULL; + pExContext = new ExampleClientContext(index); + if (!pExContext) + { + return HXR_UNEXPECTED; + } + pExContext->AddRef(); + + ppPlayer[0] = NULL; + IHXClientEngine* pEngine = GetGlobal()->pEngine; + if (HXR_OK != pEngine->CreatePlayer(*ppPlayer)) + { + HX_RELEASE(pExContext); + return HXR_FAILED; + } +#if 1 + char* pszGUIDList = NULL; + //initialize the example context + pszGUIDList = GetGlobal()->g_pszGUIDList; + { + char pszGUID[GUID_LEN + 1]; /* Flawfinder: ignore */ // add 1 for terminator + char* token = NULL; + IHXPreferences* pPreferences = NULL; + + pszGUID[0] = '\0'; + + if (pszGUIDList) + { + // Get next GUID from the GUID list + { + token = strtok(pszGUIDList, "\n\0"); + } + if (token) + { + strncpy(pszGUID, token, GUID_LEN); /* Flawfinder: ignore */ + pszGUID[GUID_LEN] = '\0'; + } + } + + ppPlayer[0]->QueryInterface(IID_IHXPreferences, + (void**) &pPreferences); + + pExContext->Init(ppPlayer[0], pPreferences, pszGUID, on_buffering_cb, on_pos_length_cb, on_state_change_cb, on_new_frame_cb, context); + + ppPlayer[0]->SetClientContext(pExContext); + + HX_RELEASE(pPreferences); + + IHXErrorSinkControl* pErrorSinkControl = NULL; + ppPlayer[0]->QueryInterface(IID_IHXErrorSinkControl, + (void**) &pErrorSinkControl); + + if (pErrorSinkControl) + { + IHXErrorSink* pErrorSink = NULL; + pExContext->QueryInterface(IID_IHXErrorSink, + (void**) &pErrorSink); + if (pErrorSink) + { + pErrorSinkControl->AddErrorSink(pErrorSink, HXLOG_EMERG, HXLOG_INFO); + } + HX_RELEASE(pErrorSink); + } + HX_RELEASE(pErrorSinkControl); + GetGlobal()->g_prefList.SetPreferences(ppPlayer[0]); + + } +#endif + HX_ASSERT(GetGlobal()->g_nPlayers < MAX_NUM_PLAYERS); + GetGlobal()->g_Players[index] = ppPlayer[0]; + GetGlobal()->g_pClientContexts[index] = pExContext; + GetGlobal()->g_nPlayers++; + + return HXR_OK; +} + +static int get_index_by_player( IHXPlayer *pPlayer) +{ + int i; + /* an simple implementation */ + for (i = 0; i < MAX_NUM_PLAYERS; i++) + { + if (GetGlobal()->g_Players[i] && GetGlobal()->g_Players[i] == pPlayer) + return i; + } + + return -1; +} + +PLAYER_API int player_openurl( void *pPlayerHandle, char *pszRawURL) +{ + HX_RESULT ret; + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + int index = get_index_by_player(pPlayer); + if (index < 0) + return HXR_FAIL; + + char *pszURLOrig = RemoveWrappingQuotes(pszRawURL); + + //if no "://" was found lets add file:// by default so that you + //can refer to local content as just ./splay ~/Content/startrek.rm, + //for example, and not ./splay file:///home/gregory/Content/startrek.rm + char* pszAddOn = NULL; + if( strstr( pszURLOrig, "://") ) + pszAddOn = (char *)""; + else + pszAddOn = (char *)"file://"; + + char *pszURL = new char[strlen(pszURLOrig)+strlen(pszAddOn)+1]; + sprintf( pszURL, "%s%s", pszAddOn, pszURLOrig ); /* Flawfinder: ignore */ + // Increment the number of URLs we have found + STDERR("opening %s on player\n", pszURL); + + GetGlobal()->g_pszURLs[index] = pszURL; + ret = pPlayer->OpenURL(pszURL); + + UINT32 sleepTime = 0; + + IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker; + if( pKicker ) + { + pKicker->Kick(HXGetCurrentThreadID(), &sleepTime); + } + + return ret; +} + +PLAYER_API int put_player( void *pPlayerHandle) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + int index; + index = get_index_by_player(pPlayer); + if (index < 0) + return HXR_FAIL; + + ExampleClientContext *pClientContext = GetGlobal()->g_pClientContexts[index]; + if (pClientContext) { + pClientContext->Release(); + pClientContext = NULL; + } + + GetGlobal()->g_pClientContexts[index] = NULL; + if (pPlayer) { + if (GetGlobal()->pEngine) { + GetGlobal()->pEngine->ClosePlayer(pPlayer); + } + pPlayer->Release(); + pPlayer = NULL; + } + GetGlobal()->g_Players[index] = NULL; + GetGlobal()->g_nPlayers--; + delete [] GetGlobal()->g_pszURLs[index]; + GetGlobal()->g_pszURLs[index] = NULL; + + return HXR_OK; +} + +PLAYER_API int player_geturl( void *pPlayerHandle, char **pszURL) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + int index = get_index_by_player(pPlayer); + if (index >= 0) { + *pszURL = GetGlobal()->g_pszURLs[index]; + return HXR_OK; + } + + return HXR_FAIL; +} + +PLAYER_API int player_begin( void *pPlayerHandle ) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + UINT32 sleepTime = 0; + pPlayer->Begin(); + +#if 0 + IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker; + if( pKicker ) + { + pKicker->Kick(HXGetCurrentThreadID(), &sleepTime); + } +#endif + return HXR_OK; +} + +PLAYER_API int player_pause( void *pPlayerHandle ) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + UINT32 sleepTime = 0; + pPlayer->Pause(); + +#if 0 + IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker; + if( pKicker ) + { + pKicker->Kick(HXGetCurrentThreadID(), &sleepTime); + } +#endif + return HXR_OK; +} + +PLAYER_API int player_stop( void *pPlayerHandle ) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + pPlayer->Stop(); + return HXR_OK; +} + +#if 0 +int main(int argc, char *argv[]) +{ + IHXPlayer *pPlayer; + init_main(); + while(1) { + get_player(&pPlayer); + player_openurl(pPlayer, argv[1]); + player_begin(pPlayer); + // sleep(2); + player_stop(pPlayer); + put_player(pPlayer); + } + deinit_main(); + return 0; +} +#endif + +PLAYER_API int player_seek(void *pPlayerHandle, int pos) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + if (pPlayer == NULL) + return HXR_FAIL; + + return pPlayer->Seek(pos); +} +PLAYER_API int player_getvolume(void *pPlayerHandle) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + if (pPlayer == NULL) + return HXR_FAIL; + + int volume = 0; + + IHXAudioPlayer* pAudioPlayer = NULL; + pPlayer->QueryInterface(IID_IHXAudioPlayer, (void**) &pAudioPlayer); + if (pAudioPlayer) + { + // Get the IHXVolume + IHXVolume* pVolume = pAudioPlayer->GetAudioVolume(); + if (pVolume) + { + volume = pVolume->GetVolume(); + } + HX_RELEASE(pVolume); + } + HX_RELEASE(pAudioPlayer); + + return volume; +} + + +PLAYER_API int player_setvolume(void *pPlayerHandle, unsigned short volume) +{ + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + if (pPlayer == NULL) + return HXR_FAIL; + + IHXAudioPlayer* pAudioPlayer = NULL; + pPlayer->QueryInterface(IID_IHXAudioPlayer, (void**) &pAudioPlayer); + if (pAudioPlayer) + { + // Get the IHXVolume + IHXVolume* pVolume = pAudioPlayer->GetAudioVolume(); + if (pVolume) + { + pVolume->SetVolume(volume); + } + HX_RELEASE(pVolume); + } + HX_RELEASE(pAudioPlayer); +} + +PLAYER_API int deinit_main() +{ + + pthread_cancel(GetGlobal()->g_pThreadKickmanId); + int ret ; + ret = pthread_join(GetGlobal()->g_pThreadKickmanId, NULL); + if (ret < 0) { + perror("pthread_join error\n"); + } +#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) + if (GetGlobal()->g_pVelocityCaps) + { + IHXPlaybackVelocityCaps* pCaps = GetGlobal()->g_pVelocityCaps; + pCaps->Release(); + GetGlobal()->g_pVelocityCaps = NULL; + } +#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */ + +#ifdef __TCS__ + g_nPlayers = 0; +#endif + + + { + IHXClientEngine* pEngine = GetGlobal()->pEngine; + + if (pEngine) + { + IHXClientEngine2* pEngine2 = NULL; + if (HXR_OK == pEngine->QueryInterface(IID_IHXClientEngine2, + (void**)&pEngine2)) + { + pEngine2->Close(); + } + HX_RELEASE(pEngine2); + } + HX_RELEASE(GetGlobal()->pEngine); + HX_RELEASE(GetGlobal()->g_pIHXKicker); + + if (GetGlobal()->pMediaPlatform) + { + // Reset() not only close the platform but also remove all + // persistent information(i.e. preferences) maintained by the + // platform + // GetGlobal()->pMediaPlatform->Reset(NULL); + GetGlobal()->pMediaPlatform->Close(); + HX_RELEASE(GetGlobal()->pMediaPlatform); + } + + if (GetGlobal()->m_fpHXMediaPlatformClose) + { + GetGlobal()->m_fpHXMediaPlatformClose(); + } + } + + + if (GetGlobal()->bEnableVerboseMode) + { + STDOUT("\nDone.\n"); + } + + if (GetGlobal()->g_pszUsername) + { + delete [] GetGlobal()->g_pszUsername; + GetGlobal()->g_pszUsername = NULL; + } + if (GetGlobal()->g_pszPassword) + { + delete [] GetGlobal()->g_pszPassword; + GetGlobal()->g_pszPassword = NULL; + } + if (GetGlobal()->g_pszGUIDFile) + { + delete [] GetGlobal()->g_pszGUIDFile; + GetGlobal()->g_pszGUIDFile = NULL; + } + if (GetGlobal()->g_pszGUIDList) + { + delete [] GetGlobal()->g_pszGUIDList; + GetGlobal()->g_pszGUIDList = NULL; + } + // If an error occurred during playback, return that + + if (GetGlobal()->g_Error != HXR_OK) + { + return GetGlobal()->g_Error; + } + // or HXR_OK (if there was more than one player) + else + { + return HXR_OK; + } +} +char* GetAppName(char* pszArgv0) +{ + char* pszAppName; + + pszAppName = strrchr(pszArgv0, '\\'); + + if (NULL == pszAppName) + { + return pszArgv0; + } + else + { + return pszAppName + 1; + } +} + +void PrintUsage(const char* pszAppName) +{ +} + + + +HXBOOL ReadGUIDFile() +{ + HXBOOL bSuccess = FALSE; + FILE* pFile = NULL; + int nNumRead = 0; + int readSize = 10000; + char* pszBuffer = new char[readSize]; + + if (GetGlobal()->g_pszGUIDFile) + { + if((pFile = fopen(GetGlobal()->g_pszGUIDFile, "r")) != NULL) + { + // Read in the entire file + nNumRead = fread(pszBuffer, sizeof(char), readSize, pFile); + pszBuffer[nNumRead] = '\0'; + + // Store it for later parsing + GetGlobal()->g_pszGUIDList = new char[nNumRead + 1]; + strcpy(GetGlobal()->g_pszGUIDList, pszBuffer); /* Flawfinder: ignore */ + + fclose(pFile); + pFile = NULL; + + if (nNumRead > 0) + { + bSuccess = TRUE; + } + } + } + + delete [] pszBuffer; + + return bSuccess; +} + +static int are_all_src_seekable(IHXPlayer *pPlayer) +{ + UINT16 nSrcCnt; + nSrcCnt = pPlayer->GetSourceCount(); + HXSource *pSource = NULL; /* This is brute-force */ + for (UINT16 i = 0; i < nSrcCnt; i++) + { + if (pPlayer->GetSource(i, (IUnknown *&)pSource) == HXR_OK) + { + if (!pSource->IsSeekable()) + return FALSE; + + + } + } + +} + +PLAYER_API int player_canseek(void *pPlayerHandle) +{ + if (!pPlayerHandle) + return FALSE; + + IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle; + ExampleClientContext* pExContext=NULL; + if (pPlayer->GetClientContext((IUnknown*&)pExContext) != HXR_OK) + return FALSE; + + if (!pExContext) + return FALSE; + + EHXClientState State = pExContext->GetState(); + + int all_src_seekable = are_all_src_seekable(pPlayer); + + HX_RELEASE(pExContext); + + if (State < HX_CLIENT_STATE_CONNECTED) + return TRUE; + + if (all_src_seekable && (!pPlayer->IsLive() || State == HX_CLIENT_STATE_PAUSED)) + return TRUE; + + return FALSE; +} + + Index: helix-libs/clientapps/clutter/player.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/player.h 2008-10-13 06:54:45.000000000 -0700 @@ -0,0 +1,60 @@ +#ifndef _PLAYER_H_ +#define _PLAYER_H_ + +#ifdef __cplusplus +#define PLAYER_API extern "C" +#else +#define PLAYER_API +#endif + +/* Duplicate of EHXClientState */ +typedef enum _EPlayerStateState +{ + PLAYER_STATE_READY = 0, // uninitialized + PLAYER_STATE_CONNECTING, // attempting to connect to sources + PLAYER_STATE_CONNECTED, // connected to sources (realized) + PLAYER_STATE_OPENING, // opening sources + PLAYER_STATE_OPENED, // opened sources + PLAYER_STATE_PREFETCHING,// obtaining resources, buffering, etc. + PLAYER_STATE_PREFETCHED, // ready for playback at time zero + PLAYER_STATE_PLAYING, // currently playing + PLAYER_STATE_PAUSED, // paused + PLAYER_STATE_SEEKING // seeking +} EHXPlayerState; + +typedef struct { + int left; + int top; + int right; + int bottom; +} PlayerRect; + +typedef struct { + PlayerRect Rect; + unsigned int cx; + unsigned int cy; +} PlayerImgInfo; + +typedef void (*on_pos_length_cb_t)(unsigned int, unsigned int, void *); +typedef void (*on_buffering_cb_t)(unsigned int, unsigned short, void *); +typedef void (*on_state_change_cb_t)(unsigned short, unsigned short, void *); +typedef void (*on_new_frame_cb_t)(unsigned char *p, unsigned int size, PlayerImgInfo *rect, void *context); + +PLAYER_API int init_main(); +PLAYER_API int deinit_main(); +PLAYER_API int get_player(void **ppPlayerHandle, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, on_state_change_cb_t on_state_change_cb, on_new_frame_cb_t on_new_frame_cb, void *context); +PLAYER_API int player_openurl( void *pPlayerHandle, char *pszRawURL); +PLAYER_API int put_player( void *pPlayerHandle); +PLAYER_API int player_geturl( void *pPlayerHandle, char **pszURL); +PLAYER_API int player_begin( void *pPlayerHandle ); +PLAYER_API int player_stop( void *pPlayerHandle ); +PLAYER_API int player_pause( void *pPlayerHandle ); +PLAYER_API unsigned int get_curr_playtime(void *pPlayerHandle); +PLAYER_API int player_seek(void *pPlayerHandle, int pos); +PLAYER_API int player_getvolume(void *pPlayerHandle); +PLAYER_API int player_setvolume(void *pPlayerHandle, unsigned short volumn); +PLAYER_API int player_canseek(void *pPlayerHandle); + + +#endif + Index: helix-libs/clientapps/clutter/preflist.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/preflist.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,142 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: preflist.cpp,v 1.2 2007/07/06 20:32:36 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ +#include "preflist.h" + +#include "hxstring.h" +#include "hxccf.h" +#include "hxprefs.h" +#include "ihxpckts.h" + +class CHXPrefInfo +{ +public: + CHXPrefInfo(const char* pKey, const char* pValue); + ~CHXPrefInfo(); + + const char* Key() const { return m_key;} + const char* Value() const { return m_value;} + +private: + CHXString m_key; + CHXString m_value; +}; + +CHXPrefInfo::CHXPrefInfo(const char* pKey, const char* pValue) : + m_key(pKey), + m_value(pValue) +{} + +CHXPrefInfo::~CHXPrefInfo() +{} + +CHXPrefList::CHXPrefList() +{} + +CHXPrefList::~CHXPrefList() +{ + Clear(); +} + +void CHXPrefList::Add(const char* pKey, const char* pValue) +{ + CHXPrefInfo* pInfo = new CHXPrefInfo(pKey, pValue); + + if (pInfo) + { + if (!m_prefInfo.AddTail(pInfo)) + { + // We failed to insert the preference. + HX_DELETE(pInfo); + } + } +} + +void CHXPrefList::Clear() +{ + while(!m_prefInfo.IsEmpty()) + { + CHXPrefInfo* pInfo = (CHXPrefInfo*)m_prefInfo.RemoveHead(); + HX_DELETE(pInfo); + } +} + +void CHXPrefList::SetPreferences(IUnknown* pContext) +{ + IHXPreferences* pPrefs = NULL; + IHXCommonClassFactory* pCCF = NULL; + + if (pContext && + (HXR_OK == pContext->QueryInterface(IID_IHXPreferences, + (void**)&pPrefs)) && + (HXR_OK == pContext->QueryInterface(IID_IHXCommonClassFactory, + (void**)&pCCF))) + { + CHXSimpleList::Iterator itr = m_prefInfo.Begin(); + + for(; itr != m_prefInfo.End(); ++itr) + { + CHXPrefInfo* pInfo = (CHXPrefInfo*)(*itr); + + IHXBuffer* pBuf = NULL; + + if ((HXR_OK == pCCF->CreateInstance(CLSID_IHXBuffer, + (void**)&pBuf)) && + (HXR_OK == pBuf->Set((const unsigned char*)pInfo->Value(), + strlen(pInfo->Value())))) + { + pPrefs->WritePref(pInfo->Key(), pBuf); + } + + HX_RELEASE(pBuf); + } + } + + HX_RELEASE(pPrefs); + HX_RELEASE(pCCF); +} Index: helix-libs/clientapps/clutter/preflist.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/preflist.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,69 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: preflist.h,v 1.2 2007/07/06 20:32:36 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ +#ifndef PREFLIST_H +#define PREFLIST_H + +#include "hxslist.h" + +class CHXPrefList +{ +public: + CHXPrefList(); + ~CHXPrefList(); + + void Add(const char* pKey, const char* pValue); + void Clear(); + + void SetPreferences(IUnknown* pContext); + +private: + CHXSimpleList m_prefInfo; +}; + +#endif /* PREFLIST_H */ Index: helix-libs/clientapps/clutter/print.cpp =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/print.cpp 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,80 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#include +#include +#include "print.h" +#ifdef WIN32_PLATFORM_PSPC +#include "hlxosstr.h" +#include +#endif + +int print2stdout(const char* pFmt, ...) +{ + va_list args; + + va_start(args, pFmt); + +#ifdef WIN32_PLATFORM_PSPC + char szMessage[512]; + int ret = vsprintf(szMessage, pFmt, args); + OutputDebugString(OS_STRING(szMessage)); +#else + int ret = vfprintf(stdout, pFmt, args); +#endif + + va_end(args); + + return ret; +} + +int print2stderr(const char* pFmt, ...) +{ + va_list args; + + va_start(args, pFmt); + +#ifdef WIN32_PLATFORM_PSPC + char szMessage[512]; + int ret = vsprintf(szMessage, pFmt, args); + OutputDebugString(OS_STRING(szMessage)); +#else + int ret = vfprintf(stderr, pFmt, args); +#endif + + va_end(args); + + return ret; +} Index: helix-libs/clientapps/clutter/print.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/print.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,60 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: RCSL 1.0/RPSL 1.0 + * + * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, are + * subject to the current version of the RealNetworks Public Source License + * Version 1.0 (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the RealNetworks Community Source License Version 1.0 + * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, + * in which case the RCSL will apply. You may also obtain the license terms + * directly from RealNetworks. You may not use this file except in + * compliance with the RPSL or, if you have a valid RCSL with RealNetworks + * applicable to this file, the RCSL. Please see the applicable RPSL or + * RCSL for the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the portions + * it created. + * + * This file, and the files included with this file, is distributed and made + * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef PRINT_H +#define PRINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _SYMBIAN +#include "platform/symbian/symbian_print.h" + +#define STDOUT symbianPrint +#define STDERR symbianPrint +#else +int print2stdout(const char* pFmt, ...); +int print2stderr(const char* pFmt, ...); +#define STDOUT print2stdout +#define STDERR print2stderr +#endif + +#ifdef __cplusplus +}; +#endif + + +#endif /* PRINT_H */ Index: helix-libs/clientapps/clutter/shmhelp.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/shmhelp.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,88 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: shmhelp.h,v 1.5 2007/07/06 20:54:01 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#if defined(USE_XWINDOWS) +#include +#include +#include +#endif + +#include "hxcom.h" +#include "hxtypes.h" + + +class ShmHelp +{ + public: + + //Helpers + static void Init(Display* pDisplay ); + static HXBOOL ShmAvailable(); + static HX_RESULT DetachSharedRegion(UCHAR**ppMem, XShmSegmentInfo* pInfo ); + static HX_RESULT CreateSharedRegion( INT32 nSize, + UCHAR**ppMem, + int* pnShmID, + XShmSegmentInfo* pInfo ); + + + protected: + + private: + static HXBOOL zm_bUseShm; + + //The X11 Segment ID.... + static int zm_nSegment; + static Display* zm_pDisplay; + + ShmHelp(); + ShmHelp(Display*); + ~ShmHelp(); + +}; + Index: helix-libs/clientapps/clutter/unix.pcf =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/unix.pcf 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,65 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: RCSL 1.0/RPSL 1.0 +# +# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. +# +# The contents of this file, and the files included with this file, are +# subject to the current version of the RealNetworks Public Source License +# Version 1.0 (the "RPSL") available at +# http://www.helixcommunity.org/content/rpsl unless you have licensed +# the file under the RealNetworks Community Source License Version 1.0 +# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, +# in which case the RCSL will apply. You may also obtain the license terms +# directly from RealNetworks. You may not use this file except in +# compliance with the RPSL or, if you have a valid RCSL with RealNetworks +# applicable to this file, the RCSL. Please see the applicable RPSL or +# RCSL for the rights, obligations and limitations governing use of the +# contents of the file. +# +# This file is part of the Helix DNA Technology. RealNetworks is the +# developer of the Original Code and owns the copyrights in the portions +# it created. +# +# This file, and the files included with this file, is distributed and made +# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, +# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS +# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. +# +# Technology Compatibility Kit Test Suite(s) Location: +# http://www.helixcommunity.org/content/tck +# +# Contributor(s): +# +# ***** END LICENSE BLOCK ***** +# + + +if( ('HELIX_FEATURE_MINI_SITE' not in project.defines) and + (platform.name in ('linux2', 'linux-i386')) and + ('HELIX_FEATURE_VIDEO' in project.defines) and + (project.BuildOption("nodll")) + ): + project.sys_libraries.append('Xv', 'Xext') + + + + +if project.BuildOption("nodll"): + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV20"): + if platform.name in ('linux2', 'linux-i386', 'win32') and sysinfo.arch == 'i386': + project.AddLibraries(GetSDKPath("rvg2dec_libs") + '[adecg2]') + else: + project.AddLibraries(GetSDKPath("rvg2dec_libs") + '[cdecg2]') + + if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30") or \ + project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"): + if project.IsDefined("HELIX_FEATURE_ANSIC_RV89COMBO"): + project.AddLibraries(GetSDKPath("rv89combo_c_libs")+"[cdec]") + else: + if platform.name in ('linux2', 'linux-i386') and sysinfo.arch == 'i386': + project.AddLibraries(GetSDKPath("rv89combo_libs")+"[adec40]") + else: + project.AddLibraries(GetSDKPath("rv89combo_libs")+"[cdec40]") + Index: helix-libs/clientapps/clutter/unixcmap.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/unixcmap.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,51 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: unixcmap.h,v 1.3 2007/07/06 20:54:01 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +EXTERN_C Colormap HXGetXColormap(Display* pDisplay, Window window); +EXTERN_C void HXFindBestXColor(Display* pDisplay, Colormap cmap, XColor* desired); Index: helix-libs/clientapps/clutter/visuals.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ helix-libs/clientapps/clutter/visuals.h 2008-10-13 06:05:49.000000000 -0700 @@ -0,0 +1,74 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: visuals.h,v 1.4 2007/07/06 20:54:01 jfinnecy Exp $ + * + * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 (the + * "GPL") in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your version of + * this file only under the terms of the GPL, and not to allow others + * to use your version of this file under the terms of either the RPSL + * or RCSL, indicate your decision by deleting the provisions above + * and replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient may + * use your version of this file under the terms of any one of the + * RPSL, the RCSL or the GPL. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef _UNIX +#error This is the UNIX platform specific implementation. +#endif + +#ifndef _VISUALS_H_ +#define _VISUALS_H_ + +#if defined(USE_XWINDOWS) +#include +#include +#include +#endif + +// +// These functions are loaded with dlsym() so turn off name mangling +// with extern "C". +// +extern "C" { + +Visual* GetBestVisual(Display* display); +Visual* GetVisual(Display* display, long mask, XVisualInfo* templ); + +} + +#endif // _VISUALS_H_