BPicture: Fix archive constructor.

[haiku.git] / src / add-ons / accelerants / common / compute_display_timing.cpp

/*
 * Copyright 2011, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */

/* Generate mode timings using the GTF Timing Standard
 *
 * Copyright (c) 2001, Andy Ritger  aritger@nvidia.com
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * o Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * o Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * o Neither the name of NVIDIA nor the names of its contributors
 *   may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *
 * This program is based on the Generalized Timing Formula(GTF TM)
 * Standard Version: 1.0, Revision: 1.0
 *
 * The GTF Document contains the following Copyright information:
 *
 * Copyright (c) 1994, 1995, 1996 - Video Electronics Standards
 * Association. Duplication of this document within VESA member
 * companies for review purposes is permitted. All other rights
 * reserved.
 *
 * While every precaution has been taken in the preparation
 * of this standard, the Video Electronics Standards Association and
 * its contributors assume no responsibility for errors or omissions,
 * and make no warranties, expressed or implied, of functionality
 * of suitability for any purpose. The sample code contained within
 * this standard may be used without restriction.
 *
 *
 *
 * The GTF EXCEL(TM) SPREADSHEET, a sample (and the definitive)
 * implementation of the GTF Timing Standard, is available at:
 *
 * ftp://ftp.vesa.org/pub/GTF/GTF_V1R1.xls
 *
 *
 *
 * This program takes a desired resolution and vertical refresh rate,
 * and computes mode timings according to the GTF Timing Standard.
 * These mode timings can then be formatted as an XFree86 modeline
 * or a mode description for use by fbset(8).
 *
 * NOTES:
 *
 * The GTF allows for computation of "margins" (the visible border
 * surrounding the addressable video); on most non-overscan type
 * systems, the margin period is zero.  I've implemented the margin
 * computations but not enabled it because 1) I don't really have
 * any experience with this, and 2) neither XFree86 modelines nor
 * fbset fb.modes provide an obvious way for margin timings to be
 * included in their mode descriptions (needs more investigation).
 *
 * The GTF provides for computation of interlaced mode timings;
 * I've implemented the computations but not enabled them, yet.
 * I should probably enable and test this at some point.
 *
 * TODO:
 *
 * o Add support for interlaced modes.
 *
 * o Implement the other portions of the GTF: compute mode timings
 *   given either the desired pixel clock or the desired horizontal
 *   frequency.
 *
 * o It would be nice if this were more general purpose to do things
 *   outside the scope of the GTF: like generate double scan mode
 *   timings, for example.
 *
 * o Error checking.
 *
 */


#include <compute_display_timing.h>

#include <math.h>
#include <stdarg.h>


//#define TRACE_COMPUTE
#ifdef TRACE_COMPUTE
#       define TRACE(x, ...)    debug_printf(x, __VA_ARGS__)
#else
#       define TRACE(x, ...)    ;
#endif


#define MARGIN_PERCENT                          1.8             // % of active vertical image
#define CELL_GRANULARITY                        8.0
        // assumed character cell granularity
#define MIN_PORCH                                       1               // minimum front porch
#define V_SYNC_WIDTH                            3               // width of vsync in lines
#define H_SYNC_PERCENT                          8.0             // width of hsync as % of total line
#define MIN_VSYNC_PLUS_BACK_PORCH       550.0   // time in microsec

// C' and M' are part of the Blanking Duty Cycle computation

#define M                                       600.0   // blanking formula gradient
#define C                                       40.0    // blanking formula offset
#define K                                       128.0   // blanking formula scaling factor
#define J                                       20.0    // blanking formula scaling factor
#define C_PRIME                         (((C - J) * K / 256.0) + J)
#define M_PRIME                         (K / 256.0 * M)


/*!     As defined by the GTF Timing Standard, compute the Stage 1 Parameters
        using the vertical refresh frequency. In other words: input a desired
        resolution and desired refresh rate, and output the GTF mode timings.
*/
status_t
compute_display_timing(uint32 width, uint32 height, float refresh,
        bool interlaced, display_timing* timing)
{
        if (width < 320 || height < 200 || width > 65536 || height > 65536
                        || refresh < 25 || refresh > 1000)
                return B_BAD_VALUE;

        bool margins = false;

        // 1. In order to give correct results, the number of horizontal
        // pixels requested is first processed to ensure that it is divisible
        // by the character size, by rounding it to the nearest character
        // cell boundary:
        //      [H PIXELS RND] = ((ROUND([H PIXELS]/[CELL GRAN RND],0))*[CELLGRAN RND])
        width = (uint32)(rint(width / CELL_GRANULARITY) * CELL_GRANULARITY);

        // 2. If interlace is requested, the number of vertical lines assumed
        // by the calculation must be halved, as the computation calculates
        // the number of vertical lines per field. In either case, the
        // number of lines is rounded to the nearest integer.
        //      [V LINES RND] = IF([INT RQD?]="y", ROUND([V LINES]/2,0),
        //              ROUND([V LINES],0))
        float verticalLines = interlaced ? (double)height / 2.0 : (double)height;

        // 3. Find the frame rate required:
        //      [V FIELD RATE RQD] = IF([INT RQD?]="y", [I/P FREQ RQD]*2,
        //              [I/P FREQ RQD])
        float verticalFieldRate = interlaced ? refresh * 2.0 : refresh;

        // 4. Find number of lines in Top margin:
        //      [TOP MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
        //              ROUND(([MARGIN%]/100*[V LINES RND]),0), 0)
        float topMargin = margins ? rint(MARGIN_PERCENT / 100.0 * verticalLines)
                : 0.0;

        // 5. Find number of lines in Bottom margin:
        //      [BOT MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
        //              ROUND(([MARGIN%]/100*[V LINES RND]),0), 0)
        float bottomMargin = margins ? rint(MARGIN_PERCENT / 100.0 * verticalLines)
                : 0.0;

        // 6. If interlace is required, then set variable [INTERLACE]=0.5:
        //      [INTERLACE]=(IF([INT RQD?]="y",0.5,0))
        float interlace = interlaced ? 0.5 : 0.0;

        // 7. Estimate the Horizontal period
        //      [H PERIOD EST] = ((1/[V FIELD RATE RQD]) - [MIN VSYNC+BP]/1000000)
        //                      / ([V LINES RND] + (2*[TOP MARGIN (LINES)])
        //                              + [MIN PORCH RND]+[INTERLACE]) * 1000000
        float horizontalPeriodEstimate = (1.0 / verticalFieldRate
                        - MIN_VSYNC_PLUS_BACK_PORCH / 1000000.0)
                / (verticalLines + (2 * topMargin) + MIN_PORCH + interlace) * 1000000.0;

        // 8. Find the number of lines in V sync + back porch:
        //      [V SYNC+BP] = ROUND(([MIN VSYNC+BP]/[H PERIOD EST]),0)
        float verticalSyncPlusBackPorch = rint(MIN_VSYNC_PLUS_BACK_PORCH
                / horizontalPeriodEstimate);

        // 10. Find the total number of lines in Vertical field period:
        //      [TOTAL V LINES] = [V LINES RND] + [TOP MARGIN (LINES)]
        //              + [BOT MARGIN (LINES)] + [V SYNC+BP] + [INTERLACE] + [MIN PORCH RND]
        float totalVerticalLines = verticalLines + topMargin + bottomMargin
                + verticalSyncPlusBackPorch + interlace + MIN_PORCH;

        // 11. Estimate the Vertical field frequency:
        //      [V FIELD RATE EST] = 1 / [H PERIOD EST] / [TOTAL V LINES] * 1000000
        float verticalFieldRateEstimate = 1.0 / horizontalPeriodEstimate
                / totalVerticalLines * 1000000.0;

        // 12. Find the actual horizontal period:
        //      [H PERIOD] = [H PERIOD EST] / ([V FIELD RATE RQD] / [V FIELD RATE EST])
        float horizontalPeriod = horizontalPeriodEstimate
                / (verticalFieldRate / verticalFieldRateEstimate);

        // 15. Find number of pixels in left margin:
        //      [LEFT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
        //                      (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /
        //                              [CELL GRAN RND]),0)) * [CELL GRAN RND], 0))
        float leftMargin = margins ? rint(width * MARGIN_PERCENT / 100.0
                        / CELL_GRANULARITY) * CELL_GRANULARITY : 0.0;

        // 16. Find number of pixels in right margin:
        //      [RIGHT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
        //                      (ROUND( ([H PIXELS RND] * [MARGIN%] / 100 /
        //                              [CELL GRAN RND]),0)) * [CELL GRAN RND], 0))
        float rightMargin = margins ? rint(width * MARGIN_PERCENT / 100.0
                        / CELL_GRANULARITY) * CELL_GRANULARITY : 0.0;

        // 17. Find total number of active pixels in image and left and right
        // margins:
        //      [TOTAL ACTIVE PIXELS] = [H PIXELS RND] + [LEFT MARGIN (PIXELS)]
        //              + [RIGHT MARGIN (PIXELS)]
        float totalActivePixels = width + leftMargin + rightMargin;

        // 18. Find the ideal blanking duty cycle from the blanking duty cycle
        // equation:
        //      [IDEAL DUTY CYCLE] = [C'] - ([M']*[H PERIOD]/1000)
        float idealDutyCycle = C_PRIME - (M_PRIME * horizontalPeriod / 1000.0);

        // 19. Find the number of pixels in the blanking time to the nearest
        // double character cell:
        //      [H BLANK (PIXELS)] = (ROUND(([TOTAL ACTIVE PIXELS]
        //                      * [IDEAL DUTY CYCLE] / (100-[IDEAL DUTY CYCLE])
        //                      / (2*[CELL GRAN RND])), 0)) * (2*[CELL GRAN RND])
        float horizontalBlank = rint(totalActivePixels * idealDutyCycle
                        / (100.0 - idealDutyCycle) / (2.0 * CELL_GRANULARITY))
                * (2.0 * CELL_GRANULARITY);

        // 20. Find total number of pixels:
        //      [TOTAL PIXELS] = [TOTAL ACTIVE PIXELS] + [H BLANK (PIXELS)]
        float totalPixels = totalActivePixels + horizontalBlank;

        // 21. Find pixel clock frequency:
        //      [PIXEL FREQ] = [TOTAL PIXELS] / [H PERIOD]
        float pixelFrequency = totalPixels / horizontalPeriod;

        // Stage 1 computations are now complete; I should really pass
        // the results to another function and do the Stage 2
        // computations, but I only need a few more values so I'll just
        // append the computations here for now */

        // 17. Find the number of pixels in the horizontal sync period:
        //      [H SYNC (PIXELS)] =(ROUND(([H SYNC%] / 100 * [TOTAL PIXELS]
        //              / [CELL GRAN RND]),0))*[CELL GRAN RND]
        float horizontalSync = rint(H_SYNC_PERCENT / 100.0 * totalPixels
                        / CELL_GRANULARITY) * CELL_GRANULARITY;

        // 18. Find the number of pixels in the horizontal front porch period:
        //      [H FRONT PORCH (PIXELS)] = ([H BLANK (PIXELS)]/2)-[H SYNC (PIXELS)]
        float horizontalFrontPorch = (horizontalBlank / 2.0) - horizontalSync;

        // 36. Find the number of lines in the odd front porch period:
        //      [V ODD FRONT PORCH(LINES)]=([MIN PORCH RND]+[INTERLACE])
        float verticalOddFrontPorchLines = MIN_PORCH + interlace;

        // finally, pack the results in the mode struct

        timing->pixel_clock = uint32(pixelFrequency * 1000);
        timing->h_display = (uint16)width;
        timing->h_sync_start = (uint16)(width + horizontalFrontPorch);
        timing->h_sync_end
                = (uint16)(width + horizontalFrontPorch + horizontalSync);
        timing->h_total = (uint16)totalPixels;
        timing->v_display = (uint16)verticalLines;
        timing->v_sync_start = (uint16)(verticalLines + verticalOddFrontPorchLines);
        timing->v_sync_end
                = (uint16)(verticalLines + verticalOddFrontPorchLines + V_SYNC_WIDTH);
        timing->v_total = (uint16)totalVerticalLines;
        timing->flags = B_POSITIVE_HSYNC | B_POSITIVE_VSYNC
                | (interlace ? B_TIMING_INTERLACED : 0);

        TRACE("GTF TIMING: %lu kHz, (%u, %u, %u, %u), (%u, %u, %u, %u)\n",
                timing->pixel_clock, timing->h_display, timing->h_sync_start,
                timing->h_sync_end, timing->h_total, timing->v_display,
                timing->v_sync_start, timing->v_sync_end, timing->v_total);

        return B_OK;
}