FileMaker Pro Custom Functions

/* TimeCodeCalculations ( inVleA ; inVleB ; FrRate ; filmFrm ; fnType ) v1.5 ABSTRACT -------- "Make everything as simple as possible, but not simpler" (Albert Einstein) TimeCodeCalculations is an attempt to perform several time-code-oriented computations using -- within a single function -- a set of non-recursive calculations. Because the subject of time-code is rather complex (ergo, prone to confusion and misunderstandings), I decided to comprise a short essay on it. Please understand that its information is compiled from books and documents published by the Society of Motion Picture and Television Engineers (SMPTE) or its associates, hence they are not personal viewpoints. This CF is better visualized in a text editor using a monotype font such as Monaco or Courier. SMPTE TIME-CODE IN BRIEF ------------------------ SMPTE stands for "Society of Motion Picture and Television Engineers"; an entity founded in 1916, whose role has been to normatize and develop technical industry standards, as well as recommend its practices and guidelines. "Time-code" is a system of standards devised during the Fifties and Sixties, but formally established in 1970, to address an unique value to individual video frames via a continuous stream of sequential data, embedded as a longitudinal (LTC) or vertical (VITC) signal. SMPTE time-code is mostly used as a common reference for synchronizing different video and/or audio souces. From the user standpoint, the SMPTE time-code system counts and displays frames presented much like real-time clock values: in Hours, Minutes, Seconds, and frames. FRAME AND FRAME RATE --------------------- A frame is one of many (often unique) consecutive still images that compose a moving picture. Frame rate, or frame frequency, is the rate at which frames move during one second. The generic unit for "per Second" is Hertz (abbreviated "Hz"), named after the German physicist Heinrich Hertz. Therefore, some technical documents use "Hz" to address frame rates. SMPTE TIME-CODE WORD -------------------- According to Sections 7 and 8 of the SMPTE-12M specification, the 80-bit SMPTE word is structured as follows: bit # Function ---- ----------- 0-3 Units of frames 4-7 First binary group 8-9 Tens of frames 10 Drop frame flag 11 Color frame flag 12-15 Second binary group 16-19 Units of seconds 20-23 Third binary group 24-26 Tens of seconds 27 Bi-Phase mark phase correction 28-31 Fourth binary group 32-35 Units of minutes 36-39 Fifth binary group 40-42 Tens of minutes 43 Binary Group Flag (BGF0) 44-47 Sixth binary group 48-51 Units of hours 52-55 Seventh binary group 56-57 Tens of hours 58 Binary Group Flag (BGF1) 59 Binary Group Flag (BGF2) 60-63 Eighth binary group 64-79 Sync Word As stated in section "SMPTE TIME-CODE IN BRIEF", SMPTE time-code encoding addresses a value to each video frame using a value associated with time: it runs from 00 to XX frames per second (XX is the frame rate), 00 to 59 seconds per minute, 00 to 59 minutes per hour, and 00 to 23 hours per day; consequentially, there are XX * 60 * 60 * 24 unique values in a 24-hour day. BROADCAST COLOR VIDEO AND DROP-FRAME ------------------------------------ Before the implementation of NTSC Color Video system in December of 1953, the standard used was 60 fields (or 30 frames) per second, which produced a full compatibility between time-code values and the actual time-of-day (if both were synchronized), as well as no discrepancy across the former and the US electrical flow rate of 60 Hz. When NTSC Color Video system was introduced, a change was required to add the additional RGB data to the transmission signal; a color subcarrier was annexed at 3.579545 MHz in order not to interfere with the audio subcarrier, and the signal rates of all other portions of the video signal yielded to the new frequency: - the Horizontal Scanning Frequency, defined as 2/455 times the subcarrier, changed from 15,750 Hz to 15,734.26 Hz; - the Vertical Scanning Frequency, also known as field rate, and defined as 2/525 times the horizontal scanning frequency, changed from 60 Hz to 59.94 Hz; - the resulting frame size became 29.97. One of the reasons for such system was to retain compatibility; it would be over-expensive -- especially to consumers -- if a different system was adopted. The TV industry, however, found that the new system produced a distortion: Since the color frame was 0.03 shorter, at a nominal frame rate of 30 frames/sec, one hour of Color Video was actually 108 frames or 3.59 seconds (3600 seconds * 0.03) LONGER than the actual hour. The "Drop Frame" standard was devised by NTSC engineers to correct this distortion. No real frames are actually dropped -- time code is only displayed that way, by skipping the first two frames (00 and 01) of every minute except every tenth minute, which results in 108 skipped-frames per hour. Note that, from the "video standpoint", there is no difference between Drop Frame and non-Drop Frame, since the frame duration remains the same. Nevertheless, since the "Drop Frame" standard (as others yet to came) was user-oriented, the counting sequence of the time-code was modified in order to bring the time value closer to the actual program's time duration. VIDEO TAPE AND DROP-FRAME ------------------------- Before the advent of VTR during the mid Fifties, the only recording medium the TV industry had was motion picture film used for kinescopes -- an expensive and time-consuming format, for the film had actually to be developed. The introduction of the 2-inch Quadruplex by Ampex in 1956, besides reducing costs and boosting the recording process speed, allowed the experimentation of cinema-based techniques, such as video editing. Since the first VTR models were Time (instead of Frame) based, attempts to perform an A-B roll editing during the early Sixties exposed an unforeseen but known snag; only, this time, it affected monochrome video as well: - 1 second / by 30 frames = 33.3667 ms; yet - 33.3667 ms * 30 frames/s = 1.001001 seconds. Such discrepancy, when projected into a full hour, generated an already-known difference: 33.3667 ms (1 fr) * 30 frames/s * 60 s/min * 60 min/hr = 3603.6 (instead of 3600) seconds per hour. The TV broadcasting industry decided to adopt the same standard devised by NTSC in 1953; hence, over a decade later, the 30 frames/s "Drop-frame" became a standard, which lasted until 1970. FRAME RATE FORMATS ------------------ Below are several frame rates in use; yet, as the Film and TV broadcasting industries evolve, a new set of standards is being devised, so this list will not be valid for much longer. - 60 frames/s (film and Advanced Television Systems Committee or ATSC) - 59.94 frames/s DF or NDF (film, ATSC) - 30 frames/s DF or NDF (US NTSC System, ATSC, Pal-M) - 29.97 frames/s DF or NDF (US NTSC System) - 25 frames/s (Pal, SECAM, DVB, ATSC) - 24 frames/s (film, ATSC) - 23.98 frames/s DF or NDF (film, ATSC) FRAME RATE VISUALIZATION ------------------------ There are few standards to visualize SMPTE time-code according to frame rate. The two commonest are: 1. the SMPTE 12-M specification, with four pairs of digits representing Hours (Hh), Minutes (Mm), Seconds (Ss), and Frames (Fr); values smaller than ten preceded by a "0"; and pairs of digits separated by a colon (":") when frame rate format is non-drop frame (NDF) or a semi-collon (";") when frame rate format is drop frame (DF); 2. the Japanese Broadcast Corporation (NKH) and Sony specification -- a variation of SMPTE's -- with three pairs of digits (Hh, Mm, Ss) separated by colons (":"), and the delineator between pairs Ss and Fr indicating wether the frame rate format is non-drop frame ":" or drip frame (";" or "."). Also, all pair of digits are preceded by "0" when values are smaller than ten. TIME-CODE AND FRAME RATE CONUNDRUM ---------------------------------- From the establishment of SMPTE time-code system of standards in 1970, there has been a ganeral confusion about some of its concepts. The first and perhaps most prominent lies in the relation between SMPTE time-code and properties "Time" and "Frame". As stated at the beginning of this text; "From the user standpoint, the SMPTE time-code system counts and displays frames presented much like real-time clock values, with values in Hh, Mm, Ss, and frames." According to SMPTE 12-M specifications, SMPTE time-code interprets property TIME based on property FRAME, which on its turn yields to a frequency rate. Time itself is immutable; only values related to frame change. For example: a 30' film remains thirty minutes long regardless the frame rate used. Since SMPTE time-code relates properties Time and Frame, it will interpret time length as number of frames; further, in order to compute the latter, a frame rate value is required. Hence, given a frame rate value of 24 frames/s, SMPTE time-code will understand thirty minutes as 43200 frames; yet, if the frame rate used is 60 frames/s, SMPTE time-code will understand thirty minutes as 108000 frames. Another missunderstanding relates to the notion of "time-code conversion". When film industry professionals use this term, they refer to the transposition of a non-time-related value to its SMPTE time-code equivalency. For instance: the conversion of frame number at a certain frame rate to SMPTE time-code, or the conversion of film footage at a certain frame rate to its SMPTE time-code equivalency. Below, a simple example: Film footage is expressed in feet plus frames. If the film format for conversion is four-sprocket-holes 35mm, a foot of film equals 16 frames. Therefore, the time-code conversion of a four-sprocket-holes 35mm film footage count of 791+3 is, 791 (feet) * 16 (frames per foot) + 3 (frames) = 12659 frames (total number of frames) (assuming that the frame rate is the film industry standard of 24 fr/sec and the starting frame or offset is 00:00:00:00, SMPTE time-code can be calculated as follows) -> Frames = Int ( Mod ( 12659 ; 24 ) ) = 11 -> Seconds = Int ( Mod ( ( 12659 / 24 ) ; 60 ) ) = 47 -> Minutes = Int ( Mod ( ( 12659 / 24 / 60 ) ; 60 ) ) = 8 -> Hours = Int ( 12659 / 24 / 60 / 60 ) = 0 results in SMPTE time-code 00:08:47:11. However, when professionals from the TV broacasting industry allude to time-code conversion, they refer to the frame rate conversion of a given SMPTE time-code. Frame rate conversion, as the term implies, is the transposition of a SMPTE time-code spot from a frame rate into a new frame rate . As seen in the beginning of this section, albeit the length of time doesn't change regardless the frame frequency, the number of frames does, thus such conversion is used when frame property is at focus. Below, another simple example: The conversion of SMPTE time-code 00:10:00:00 from frame rate 30 frames/s to frame rate 24 frames/s, 1. SMPTE time-code 00:10:00:00 at 30 frames/s is converted to its total-frames equivalency --> Frames = 00 + --> Seconds = 00 * 30 frames/s frame rate = 0 + --> Minutes = 10 * 60 secs per minute * 30 frames/s frame rate = 18000 + --> Hours = 0 * 60 minutes per hour * 60 secs per minute * 30 frames/s frame rate = 0 results in 18000 frames; 2. total-frames value of 18000 frames is converted to SMPTE time-code equivalency at 24 frames/s frame rate -> Frames = Int ( Mod ( 18000 ; 24 ) ) = 0 -> Seconds = Int ( Mod ( ( 18000 / 24 ) ; 60 ) ) = 0 -> Minutes = Int ( Mod ( ( 18000 / 24 / 60 ) ; 60 ) ) = 12 -> Hours = Int ( 18000 / 24 / 60 / 60 ) = 0 results in 00:12:00:00. note: in both calculations, complications such as pull-down and drop frame were not taken into account. THE FUTURE OF SMPTE TIME-CODE ----------------------------- Below is an excerpt from the introduction of a SMPTE's document entitled "Time-Labeling and Synchronization", released in early 2008: "The Society of Motion Picture and Television Engineers (SMPTE) and the European Broadcasting Union (EBU) have formed a Joint Task Force to examine and standardize future needs for timing and synchronization in moving picture and related industries ... CURRENT METHODS of timing and synchronization for television, audio, and other moving picture signals rely on standards that have been in place for nearly forty years and were revised over thirty years ago. These ARE BECOMING increasingly INAPPROPRIATE FOR THE DIGITAL AGE WITH, for example, networked content sharing and the higher frame rates appropriate to HDTV, UHDTV and other image formats. THEY IMPOSE UNACCEPTABLE LIMITATIONS FOR THE FUTURE AND MUST BE REPLACED BY NEW TIME-LABELLING AND SYNCHRONIZATION TECHNOLOGY." Three years before, NATO published NATO STANDARDIZATION AGREEMENT (STANAG) on digital motion agreement standard; a set of rules to standardize globally digital audio and video recording and broadcasting. Together, these documents suggest that the days of SMPTE time-code standards as people know them are probably counted. Whereas for those directly or indirectly involved with the video industry such change represents a whole new set of equipment to acquire as well as new standards to learn and yield to, hopefully the next system will be based on qualities missing nowadays, such as clearness, objetivity, and universality. WHAT TO EXPECT FROM THIS CUSTOM FUNCTION ---------------------------------------- As stated in the Abstract, this Custom Function attempts to perform several time-code-oriented calculations using, within a single function, a set of non-recursive subroutines. As of this version, the possible calculations are: 1. ("tcDiff") the time lag between two SMPTE time-code spots - based on frame rate - two different SMPTE time-code values are required - result in SMPTE time-code 2. ("tcAxle") the midpoint of • two different SMPTE time-code spots - based on frame rate - two SMPTE time-code values are required - result in SMPTE time-code • a SMPTE time-code spot and a frame number - based on frame rate - SMPTE time-code and a (positive or negative) frame number values are required - result in SMPTE time-code - negative results will return null • two different frame numbers - based on frame rate - two frame number values are required - result in SMPTE time-code - negative results will return null 3. ("tcSum") the sum or subtraction of • a SMPTE time-code spot and a frame number - positive frame number are added to SMPTE time-code value - negative frame number are subtracted from SMPTE time-code value - based on frame rate - result in SMPTE time-code - negative results will return "error_02" • two time-code spots (sum only) - based on frame rate - result in SMPTE time-code 4. ("tcCvn") the conversion from SMPTE time-code to film footage and vice-versa • conversion to SMPTE time-code if film footage value is used - based on frame rate and film format - valid frame rates are film-industry-related only (24 and 25 frames/s) - a film footage value is required in parameter "inVleA" - parameter "inVleB" shall be empty ("") - result in SMPTE time-code; • conversion to film footage if SMPTE time-code value is used - based on frame rate and film format - valid frame rates are film-industry-related only (24 and 25 frames/s) - a SMPTE time-code spot is required in parameter "inVleA" - parameter "inVleB" shall be empty ("") - result in film footage 5. ("frCvn") the frame rate conversion of a SMPTE time-code spot - based on two frame rates - a SMPTE time-code spot is required in parameter "inVleA" - parameter "inVleB" shall be empty ("") - result in SMPTE time-code These calculations are focused to aid music and sound professionals related to the Film Industry. CUSTOM FUNCTION PARAMETERS -------------------------- a. inVleA (input value A) String Type: Text, Number, or Both Text if parameter describes DF or NDF SMPTE time-code Number if parameter describes number of frames Both if parameter describes film footage Example: DF time-code: "00;00;25;12" NDF time-code: "00:00:25:12" Frame Number: 5240 Film Footage: "415+4" b. inVleB (input value B) String Type: Text, Number, or Both Text if parameter describes DF or NDF SMPTE time-code Number if parameter describes frame number Example: DF time-code - "00;13;51;22" NDF time-code - "00:13:51:22" Frame Number - 37822 notes: • some non-linear video editing systems wipe empty values ("00") from their time-code digits "Hh" and "Mm". If SMPTE time-code values is used in "inVleA" or "inVleB" or both, please make sure at least the last two valid pair of digits (seconds and frames) are inserted; • if the chosen "fnType" value is "tcCvn", the CF refers only to value in parameter "inVleA" for conversion c. frRate (frame rate) String Type: Text; one or two values from list of values List of Values: "60", "59.94DF", "30NDF", "29.97DF", "25", "24", and "23.976DF" Example: "25" if calculation type is 1, 2, 3, or 4 (as described in section "WHAT TO EXPECT FROM THIS CUSTOM FUNCTION"); "29.97DF,30NDF" if calculation type is 5 notes: • a single frame rate value is required for calculation types 1 to 4; • two comma-separated values are required to perform the frame rate conversion calculation; • values "59.94NDF", "30DF", "29.97NDF", and "23.976NDF" are industry-related, and were not included in this version to avoid redundancy d. filmFrm (film format) String Type: Text; one or two values from list of values List of Values: Used Film formats "35mm", "16mm", "S8mm", "8mm" Example: "35mm" note: This CF computes only 4-sprockret-hole "35mm" film e. fnType (function type) String Type: Text; one value from list of values List of Values: "tcDiff", "tcAxle", "tcSum", "tcCvn", and "frCvn" Example: "tcAxle" FINAL CONSIDERATIONS -------------------- • throughout the CF's code -- as an attempt to document the latter -- you will find various annotations explaining what a calculation (or a group of them) does; • the time-code formulas used are derived from two methods devised by Andrew Duncan -- an Engineer, Mathematician, and Computer Language Programmer whose work, ideas, and formulae, have helped me plenty in the past; • for this CF to work properly, parameters values shall yield to all conditions specified in sections "WHAT TO EXPECT FROM THIS CUSTOM FUNCTION" and "CUSTOM FUNCTION PARAMETERS"; • this CF has been written and tested only on Macintoshes; please review some of the syntax if you plan to use it in Windows; • as stated at the beginning of this document, the essay's information is compiled from several SMPTE sources, thus are not personal views. Hence, only remarks addressed to the CF code will be answered; derogatory or ad hominem comments toward the essay's content and/or the formulae will be disregarded; • I want to express my fullest gratitude to all who have helped to improve this CF, including (but not restricted to): Mr. Andrew Duncan; Mr. Jonathan Starr, for who I hold great admiration and respect; Mr. Mikhail Edoshin, whose adroitness as well as generosity and humaneness are examples to be followed, and; for the same reasons, Mr. Geoff Coffey and his mates from "Six Fried Rice". My deepest gratitude to you. © 2010 Edward Souza, based on formulae developed by Andrew Duncan */ Let ( [ /*sets values for parameters frRate, filmFrm, and fnType choices in list format; sets filmFrm footage equivalencies in list format*/ frRateLst = "60" & ¶ & "59.94DF" & ¶ & "30NDF" & ¶ & "29.97DF" & ¶ & "25" & ¶ & "24" & ¶ & "23.976DF"; filmFrmLst = "35mm" & ¶ & "16mm" & ¶ & "S8mm" & ¶ & "8mm"; perFootLst = "16" & ¶ & "40" & ¶ & "72" & ¶ & "80"; fnTypeLst = "tcDiff" & ¶ & "tcAxle" & ¶ & "tcSum" & ¶ & "tcCvn" & ¶ & "frCvn"; /*decouples and validates values from parameters inVleA, inVleB, and frRate*/ signVleA = Filter ( Substitute ( inVleA ; [ ";" ; ":" ] ; [ "." ; ":" ] ) ; ":+" ); signVleB = Filter ( Substitute ( inVleB ; [ ";" ; ":" ] ; [ "." ; ":" ] ) ; ":+" ); strgVleA = Filter ( inVleA ; "0123456789" ); strgVleB = Filter ( inVleB ; "0123456789" ); lenVleA = Length ( strgVleA ); lenVleB = Length ( strgVleB ); sepFrRate = Filter ( frRate ; "," ); frRateOgn = Choose ( Length ( sepFrRate ); Filter ( frRate ; "0123456789." ); Filter ( LeftValues ( Substitute ( frRate ; "," ; "¶" ) ; 1 ) ; "0123456789." ); "null" ); frRateNew = Choose ( Length ( sepFrRate ); ""; Filter ( RightValues ( Substitute ( frRate ; "," ; " ¶ " ) ; 1 ) ; "0123456789." ); "null" ); frRateOgnDF = PatternCount ( frRateOgn ; "." ); frRateNewDF = PatternCount ( frRateNew ; "." ); vldVleA = Case ( PatternCount ( signVleA ; "+" ) = 1; //value is film footage Substitute ( inVleA ; "+" ; "¶" ); PatternCount ( signVleA ; ":" ) > 0; //value is smpte time-code Substitute ( inVleA ; [ ";" ; "¶" ] ; [ "." ; "¶" ] ; [ ":" ; "¶" ] ); inVleA //value is number of frames ); vldVleB = Case ( PatternCount ( signVleB ; "+" ) = 1; "null"; PatternCount ( signVleB ; ":" ) > 0; Substitute ( inVleB ; [ ";" ; "¶" ] ; [ "." ; "¶" ] ; [ ":" ; "¶" ] ); inVleB ); /*establishes values from parameters frRate, filmFrm, and fnType as list value numbers; assigns a filmFrmVls value equivalency to chosen filmFrmLst value*/ frRateVle = If ( Position ( ¶ & frRateLst & ¶ ; ¶ & frRateOgn & ¶ ; 1 ; 1 ); ValueCount ( Middle ( frRateLst ; 1 ; Position ( ¶ & frRateLst & ¶ ; ¶ & frRateOgn & ¶ ; 1 ; 1 ) + Length ( frRateOgn ) - 1 ) ); 0 ); filmFrmVle = If ( Position ( ¶ & filmFrmLst & ¶ ; ¶ & filmFrm & ¶ ; 1 ; 1 ); ValueCount ( Middle ( filmFrmLst ; 1 ; Position ( ¶ & filmFrmLst & ¶ ; ¶ & filmFrm & ¶ ; 1 ; 1 ) + Length ( filmFrm ) - 1 ) ); 0 ); filmFrmEqv = GetValue ( perFootLst ; filmFrmVle ); fnTypeVle = If ( Position ( ¶ & fnTypeLst & ¶ ; ¶ & fnType & ¶ ; 1 ; 1 ); ValueCount ( Middle ( fnTypeLst ; 1 ; Position ( ¶ & fnTypeLst & ¶ ; ¶ & fnType & ¶ ; 1 ; 1 ) + Length ( fnType ) - 1 ) ); 0 ); /*rounds frRateOgn to its ceiling without decimals for use with SMPTE time-code to number of frames conversion; rounds frRateNew specifies to its ceiling without decimals.*/ frRtOgnCnv = Round ( frRateOgn ; 0 ); frRtNewCnv = Round ( frRateNew ; 0 ); /*specifies drop frame variables*/ dropFrsOgn = Round ( ( frRateOgn * 0.066667 ) ; 0 ); dropFrsNew = Round ( ( frRateNew * 0.066667 ) ; 0 ); /*parses and converts "inVleA" and "inVleB" to their number of frame equivalencies */ inVleNumFrsA = Case ( PatternCount ( signVleA ; "+" ) = 1; //parameter value is footage GetValue ( vldVleA ; 1 ) * filmFrmEqv + GetValue ( vldVleA ; 2 ); PatternCount ( signVleA ; ":" ) > 0; //parameter value is SMPTE time-code Let ( [ FrA = GetAsNumber ( RightValues ( vldVleA ; 1 ) ); SsA = Case ( lenVleA = 4; GetAsNumber ( LeftValues ( vldVleA ; 1 ) ); lenVleA = 5 or lenVleA = 6; GetAsNumber ( GetValue ( vldVleA ; 2 ) ); lenVleA = 7 or lenVleA = 8; GetAsNumber ( GetValue ( vldVleA ; 3 ) ) ); MmA = Case ( lenVleA = 4; 0; lenVleA = 5 or lenVleA = 6; GetAsNumber ( GetValue ( vldVleA ; 1 ) ); lenVleA = 7 or lenVleA = 8; GetAsNumber ( GetValue ( vldVleA ; 2 ) ) ); HhA = Case ( lenVleA ≥ 4 and lenVleA ≤ 6; 0; lenVleA = 7 or lenVleA = 8; GetAsNumber ( GetValue ( vldVleA ; 1 ) ) ) ]; If ( (HhA < 24) and (MmA < 60) and (SsA < 60) and (FrA < frRtOgnCnv); ( ( HhA * 3600 * frRtOgnCnv ) + ( MmA * 60 * frRtOgnCnv ) + ( SsA * frRtOgnCnv ) + FrA ) - Choose ( frRateOgnDF; 0; ( dropFrsOgn * ( ( ( 60 * HhA ) + MmA ) - Int ( ( ( 60 * HhA ) + MmA ) / 10 ) ) ) ); 0 ) ); vldVleA //parameter value is number of frames ); inVleNumFrsB = Case ( PatternCount ( signVleB ; "+" ) = 1; //parameter value is footage GetValue ( vldVleB ; 1 ) * filmFrmEqv + GetValue ( vldVleB ; 2 ); PatternCount ( signVleB ; ":" ) > 0; //parameter value is SMPTE time-code Let ( [ FrB = GetAsNumber ( RightValues ( vldVleB ; 1 ) ); SsB = Case ( lenVleB = 4; GetAsNumber ( LeftValues ( vldVleB ; 1 ) ); lenVleB = 5 or lenVleB = 6; GetAsNumber ( GetValue ( vldVleB ; 2 ) ); lenVleB = 7 or lenVleB = 8; GetAsNumber ( GetValue ( vldVleB ; 3 ) ) ); MmB = Case ( lenVleB = 4; 0; lenVleB = 5 or lenVleB = 6; GetAsNumber ( GetValue ( vldVleB ; 1 ) ); lenVleB = 7 or lenVleB = 8; GetAsNumber ( GetValue ( vldVleB ; 2 ) ) ); HhB = Case ( lenVleB ≥ 4 and lenVleB ≤ 6; 0; lenVleB = 7 or lenVleB = 8; GetAsNumber ( GetValue ( vldVleB ; 1 ) ) ) ]; If ( (HhB < 24) and (MmB < 60) and (SsB < 60) and (FrB < frRtOgnCnv); ( ( HhB * 3600 * frRtOgnCnv ) + ( MmB * 60 * frRtOgnCnv ) + ( SsB * frRtOgnCnv ) + FrB ) - Choose ( frRateOgnDF; 0; ( dropFrsOgn * ( ( ( 60 * HhB ) + MmB ) - Int ( ( ( 60 * HhB ) + MmB ) / 10 ) ) ) ); 0 ) ); vldVleB //parameter value is number of frames ); /*specifies calculated number of frames (total frames) based on fnType*/ totFrs = Let ( validTotFrs = Choose ( fnTypeVle; ""; If ( inVleNumFrsB > inVleNumFrsA; inVleNumFrsB - inVleNumFrsA; inVleNumFrsA - inVleNumFrsB ); Int ( ( inVleNumFrsA + inVleNumFrsB ) / 2 ); inVleNumFrsA + inVleNumFrsB; inVleNumFrsA; inVleNumFrsA ); If ( validTotFrs > 0; validTotFrs; "error" ) ); // $debug_totFrs = totFrs; /*specifies other variables for conversion to SMPTE time-code*/ FrRtCnv = If ( fnTypeVle ≠ 5; frRtOgnCnv; frRtNewCnv ); frsPerHour = If ( fnTypeVle ≠ 5; Round ( ( frRateOgn * 3600 ) ; 0 ); Round ( ( frRateNew * 3600 ) ; 0 ) ); frsPer10Min = If ( fnTypeVle ≠ 5; Round ( ( frRateOgn * 600 ) ; 0 ); Round ( ( frRateNew * 600 ) ; 0 ) ); frsPerMin = If ( fnTypeVle ≠ 5; Round ( ( frRateOgn * 60 ) ; 0 ) - dropFrsOgn; Round ( ( frRateNew * 60 ) ; 0 ) - dropFrsNew ); constD = Int ( totFrs / frsPer10Min ); constM = Mod ( totFrs ; frsPer10Min ); /*converts NDF number of frames to DF based on "two-frame-drop per minute but every tenth minute" accordng to function type*/ totFrsDF = If ( fnType ≠ 5; If ( constM > dropFrsOgn; totFrs + ( dropFrsOgn * 9 * constD ) + ( dropFrsOgn * ( ( constM - dropFrsOgn ) / frsPerMin ) ); totFrs + ( dropFrsOgn * 9 * constD ) ); If ( constM > dropFrsNew; totFrs + ( dropFrsNew * 9 * constD ) + ( dropFrsNew * ( ( constM - dropFrsNew ) / frsPerMin ) ); totFrs + ( dropFrsNew * 9 * constD ) ) ); /*these are the formulae used to convert from number of frames to film footage, SMPTE time-code, and time. There are situations where redundancies between DF and NDF values were observed; however, it is better to distinguish both formats*/ filmFtgCnv = Int ( totFrs / filmFrmEqv ) & "+" & Mod ( totFrs ; filmFrmEqv ); vleHhDF = Right ( "00" & Int ( totFrsDF / FrRtCnv / 60 / 60 ) ; 2 ); vleHhNDF = Right ( "00" & Int ( totFrs / FrRtCnv / 60 / 60 ) ; 2 ); vleMmDF = Right ( "00" & Int ( Mod ( ( totFrsDF / FrRtCnv / 60 ) ; 60 ) ) ; 2 ); vleMmNDF = Right ( "00" & Int ( Mod ( ( totFrs / FrRtCnv / 60 ) ; 60 ) ) ; 2 ); vleSsDF = Right ( "00" & Int ( Mod ( ( totFrsDF / FrRtCnv ) ; 60 ) ) ; 2 ); vleSsNDF = Right ( "00" & Int ( Mod ( ( totFrs / FrRtCnv ) ; 60 ) ) ; 2 ); vleFrDF = Right ( "00" & Int ( Mod ( totFrsDF ; FrRtCnv ) ) ; 2 ); vleFrNDF = Right ( "00" & Int ( Mod ( totFrs ; FrRtCnv ) ) ; 2 ) ]; Case ( IsEmpty ( inVleA ) and IsEmpty ( FrRate ) and IsEmpty ( fnType ); "error_01"; //these parameters are required to all calculations totFrs = "error"; "error_02 - calc value is negative"; fnTypeVle = 1; Case ( not IsEmpty ( inVleB ) and PatternCount ( signVleA ; ":" ) > 0 and PatternCount ( signVleB ; ":" ) > 0; Choose ( frRateOgnDF; vleHhNDF & ":" & vleMmNDF & ":" & vleSsNDF & ":" & vleFrNDF; vleHhDF & ";" & vleMmDF & ";" & vleSsDF & ";" & vleFrDF ); "error_03a" //function type requires valid inVleA and inVleB values ); fnTypeVle = 2; Case ( not IsEmpty ( inVleB ) and inVleB > 0 and PatternCount ( signVleA ; "+" ) = 0; Choose ( frRateOgnDF; vleHhNDF & ":" & vleMmNDF & ":" & vleSsNDF & ":" & vleFrNDF; vleHhDF & ";" & vleMmDF & ";" & vleSsDF & ";" & vleFrDF ); "error_03b" //function type requires valid inVleA and inVleB values ); fnTypeVle = 3; Case ( not IsEmpty ( inVleB ) and PatternCount ( signVleA ; "+" ) = 0 and PatternCount ( signVleB ; "+" ) = 0; Choose ( frRateOgnDF; vleHhNDF & ":" & vleMmNDF & ":" & vleSsNDF & ":" & vleFrNDF; vleHhDF & ";" & vleMmDF & ";" & vleSsDF & ";" & vleFrDF ); "error_03c" //function type requires valid inVleA and inVleB values ); fnTypeVle = 4; Case ( filmFrm = "35mm" or filmFrm = "16mm" or filmFrm = "S8mm" or filmFrm = "8mm"; Case ( PatternCount ( signVleA ; "+" ) = 1; Choose ( frRateOgnDF; vleHhNDF & ":" & vleMmNDF & ":" & vleSsNDF & ":" & vleFrNDF; vleHhDF & ";" & vleMmDF & ";" & vleSsDF & ";" & vleFrDF ); PatternCount ( signVleA ; ":" ) > 0; filmFtgCnv; "error_04a" //function type requires signVleA to accord to either ); "error_04b" // function type requires a valid filmFrm value ); fnTypeVle = 5; Case ( Length ( sepFrRate ) = 1 and PatternCount ( Substitute ( inVleA ; [ ";" ; ":" ] ; [ "." ; ":" ] ) ; ":" ) > 0; Choose ( frRateNewDF; vleHhNDF & ":" & vleMmNDF & ":" & vleSsNDF & ":" & vleFrNDF; vleHhDF & ";" & vleMmDF & ";" & vleSsDF & ";" & vleFrDF ); "error_05" //two frame rates separated by a comma and a valid SMPTE time-code are required for this function type ) ) )
 Then copy & paste into FileMaker Advanced's Edit Custom Function window.