git.sesse.net Git - mlt/blob - src/framework/mlt_geometry.c

   1 /*
   2  * mlt_geometry.c -- provides the geometry API
   3  * Copyright (C) 2004-2005 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "mlt_geometry.h"
  22 #include "mlt_tokeniser.h"
  23 #include "mlt_factory.h"
  24 #include "mlt_profile.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 typedef struct geometry_item_s
  31 {
  32         struct mlt_geometry_item_s data;
  33         struct geometry_item_s *next, *prev;
  34 }
  35 *geometry_item;
  36
  37 typedef struct
  38 {
  39         char *data;
  40         int length;
  41         int nw;
  42         int nh;
  43         geometry_item item;
  44 }
  45 geometry_s, *geometry;
  46
  47 // Create a new geometry structure
  48 mlt_geometry mlt_geometry_init( )
  49 {
  50         mlt_geometry self = calloc( 1, sizeof( struct mlt_geometry_s ) );
  51         if ( self != NULL )
  52         {
  53                 self->local = calloc( 1, sizeof( geometry_s ) );
  54                 if ( self->local != NULL )
  55                 {
  56                         geometry g = self->local;
  57                         g->nw = 720;
  58                         g->nh = 576;
  59                 }
  60                 else
  61                 {
  62                         free( self );
  63                         self = NULL;
  64                 }
  65         }
  66         return self;
  67 }
  68
  69 /** A linear step
  70 */
  71
  72 static inline double linearstep( double start, double end, double position, int length )
  73 {
  74         double o = ( end - start ) / length;
  75         return start + position * o;
  76 }
  77
  78 static void mlt_geometry_virtual_refresh( mlt_geometry self )
  79 {
  80         geometry g = self->local;
  81
  82         // Parse of all items to ensure unspecified keys are calculated correctly
  83         if ( g->item != NULL )
  84         {
  85                 int i = 0;
  86                 for ( i = 0; i < 5; i ++ )
  87                 {
  88                         geometry_item current = g->item;
  89                         while( current != NULL )
  90                         {
  91                                 int fixed = current->data.f[ i ];
  92                                 if ( !fixed )
  93                                 {
  94                                         geometry_item prev = current->prev;
  95                                         geometry_item next = current->next;
  96
  97                                         double prev_value = 0;
  98                                         double next_value = 0;
  99                                         double value = 0;
 100
 101                                         while( prev != NULL && !prev->data.f[ i ] ) prev = prev->prev;
 102                                         while( next != NULL && !next->data.f[ i ] ) next = next->next;
 103
 104                                         switch( i )
 105                                         {
 106                                                 case 0:
 107                                                         if ( prev ) prev_value = prev->data.x;
 108                                                         if ( next ) next_value = next->data.x;
 109                                                         break;
 110                                                 case 1:
 111                                                         if ( prev ) prev_value = prev->data.y;
 112                                                         if ( next ) next_value = next->data.y;
 113                                                         break;
 114                                                 case 2:
 115                                                         if ( prev ) prev_value = prev->data.w;
 116                                                         if ( next ) next_value = next->data.w;
 117                                                         break;
 118                                                 case 3:
 119                                                         if ( prev ) prev_value = prev->data.h;
 120                                                         if ( next ) next_value = next->data.h;
 121                                                         break;
 122                                                 case 4:
 123                                                         if ( prev ) prev_value = prev->data.mix;
 124                                                         if ( next ) next_value = next->data.mix;
 125                                                         break;
 126                                         }
 127
 128                                         // This should never happen
 129                                         if ( prev == NULL )
 130                                                 current->data.f[ i ] = 1;
 131                                         else if ( next == NULL )
 132                                                 value = prev_value;
 133                                         else
 134                                                 value = linearstep( prev_value, next_value, current->data.frame - prev->data.frame, next->data.frame - prev->data.frame );
 135
 136                                         switch( i )
 137                                         {
 138                                                 case 0: current->data.x = value; break;
 139                                                 case 1: current->data.y = value; break;
 140                                                 case 2: current->data.w = value; break;
 141                                                 case 3: current->data.h = value; break;
 142                                                 case 4: current->data.mix = value; break;
 143                                         }
 144                                 }
 145
 146                                 // Move to the next item
 147                                 current = current->next;
 148                         }
 149                 }
 150         }
 151 }
 152
 153 static int mlt_geometry_drop( mlt_geometry self, geometry_item item )
 154 {
 155         geometry g = self->local;
 156
 157         if ( item == g->item )
 158         {
 159                 g->item = item->next;
 160                 if ( g->item != NULL )
 161                         g->item->prev = NULL;
 162                 // To ensure correct seeding, ensure all values are fixed
 163                 if ( g->item != NULL )
 164                 {
 165                         g->item->data.f[0] = 1;
 166                         g->item->data.f[1] = 1;
 167                         g->item->data.f[2] = 1;
 168                         g->item->data.f[3] = 1;
 169                         g->item->data.f[4] = 1;
 170                 }
 171         }
 172         else if ( item->next != NULL && item->prev != NULL )
 173         {
 174                 item->prev->next = item->next;
 175                 item->next->prev = item->prev;
 176         }
 177         else if ( item->next != NULL )
 178         {
 179                 item->next->prev = item->prev;
 180         }
 181         else if ( item->prev != NULL )
 182         {
 183                 item->prev->next = item->next;
 184         }
 185
 186         free( item );
 187
 188         return 0;
 189 }
 190
 191 static void mlt_geometry_clean( mlt_geometry self )
 192 {
 193         geometry g = self->local;
 194         if ( g->data )
 195                 free( g->data );
 196         g->data = NULL;
 197         while( g->item )
 198                 mlt_geometry_drop( self, g->item );
 199 }
 200
 201 // Parse the geometry specification for a given length and normalised width/height (-1 for default)
 202 // data is constructed as: [frame=]X/Y:WxH[:mix][!][;[frame=]X/Y:WxH[:mix][!]]*
 203 // and X, Y, W and H can have trailing % chars to indicate percentage of normalised size
 204 // Append a pair's value with ! to enable distort.
 205 int mlt_geometry_parse( mlt_geometry self, char *data, int length, int nw, int nh )
 206 {
 207         int i = 0;
 208
 209         // Create a tokeniser
 210         mlt_tokeniser tokens = mlt_tokeniser_init( );
 211
 212         // Get the local/private structure
 213         geometry g = self->local;
 214
 215         // Clean the existing geometry
 216         mlt_geometry_clean( self );
 217
 218         // Update the info on the data
 219         if ( length != -1 )
 220                 g->length = length;
 221         if ( nw != -1 )
 222                 g->nw = nw;
 223         if ( nh != -1 )
 224                 g->nh = nh;
 225         if ( data != NULL )
 226                 g->data = strdup( data );
 227
 228         // Tokenise
 229         if ( data != NULL )
 230                 mlt_tokeniser_parse_new( tokens, data, ";" );
 231
 232         // Iterate through each token
 233         for ( i = 0; i < mlt_tokeniser_count( tokens ); i ++ )
 234         {
 235                 struct mlt_geometry_item_s item;
 236                 char *value = mlt_tokeniser_get_string( tokens, i );
 237
 238                 // Set item to 0
 239                 memset( &item, 0, sizeof( struct mlt_geometry_item_s ) );
 240
 241                 // Now parse the item
 242                 mlt_geometry_parse_item( self, &item, value );
 243
 244                 // Now insert into place
 245                 mlt_geometry_insert( self, &item );
 246         }
 247
 248         // Remove the tokeniser
 249         mlt_tokeniser_close( tokens );
 250
 251         // ???
 252         return 0;
 253 }
 254
 255 // Conditionally refresh in case of a change
 256 int mlt_geometry_refresh( mlt_geometry self, char *data, int length, int nw, int nh )
 257 {
 258         geometry g = self->local;
 259         int changed = ( length != -1 && length != g->length );
 260         changed = changed || ( nw != -1 && nw != g->nw );
 261         changed = changed || ( nh != -1 && nh != g->nh );
 262         changed = changed || ( data != NULL && ( g->data == NULL || strcmp( data, g->data ) ) );
 263         if ( changed )
 264                 return mlt_geometry_parse( self, data, length, nw, nh );
 265         return -1;
 266 }
 267
 268 int mlt_geometry_get_length( mlt_geometry self )
 269 {
 270         // Get the local/private structure
 271         geometry g = self->local;
 272
 273         // return the length
 274         return g->length;
 275 }
 276
 277 void mlt_geometry_set_length( mlt_geometry self, int length )
 278 {
 279         // Get the local/private structure
 280         geometry g = self->local;
 281
 282         // set the length
 283         g->length = length;
 284 }
 285
 286 int mlt_geometry_parse_item( mlt_geometry self, mlt_geometry_item item, char *value )
 287 {
 288         int ret = 0;
 289
 290         // Get the local/private structure
 291         geometry g = self->local;
 292
 293         if ( value != NULL && strcmp( value, "" ) )
 294         {
 295                 char *p = strchr( value, '=' );
 296                 int count = 0;
 297                 double temp;
 298
 299                 // Determine if a position has been specified
 300                 if ( p != NULL )
 301                 {
 302                         temp = atof( value );
 303                         if ( temp > -1 && temp < 1 )
 304                                 item->frame = temp * g->length;
 305                         else
 306                                 item->frame = temp;
 307                         value = p + 1;
 308                 }
 309
 310                 // Special case - frame < 0
 311                 if ( item->frame < 0 )
 312                         item->frame += g->length;
 313
 314                 // Obtain the current value at this position - self allows new
 315                 // frames to be created which don't specify all values
 316                 mlt_geometry_fetch( self, item, item->frame );
 317
 318                 // Special case - when an empty string is specified, all values are fixed
 319                 // TODO: Check if this is logical - it's convenient, but it's also odd...
 320                 if ( !*value )
 321                 {
 322                         item->f[0] = 1;
 323                         item->f[1] = 1;
 324                         item->f[2] = 1;
 325                         item->f[3] = 1;
 326                         item->f[4] = 1;
 327                 }
 328
 329                 // Iterate through the remainder of value
 330                 while( *value )
 331                 {
 332                         // Get the value
 333                         temp = strtod( value, &p );
 334
 335                         // Check if a value was specified
 336                         if ( p != value )
 337                         {
 338                                 // Handle the % case
 339                                 if ( *p == '%' )
 340                                 {
 341                                         if ( count == 0 || count == 2 )
 342                                                 temp *= g->nw / 100.0;
 343                                         else if ( count == 1 || count == 3 )
 344                                                 temp *= g->nh / 100.0;
 345                                         p ++;
 346                                 }
 347
 348                                 // Special case - distort token
 349                                 if ( *p == '!' || *p == '*' )
 350                                 {
 351                                         p ++;
 352                                         item->distort = 1;
 353                                 }
 354
 355                                 // Actually, we don't care about the delimiter at all..
 356                                 if ( *p ) p ++;
 357
 358                                 // Assign to the item
 359                                 switch( count )
 360                                 {
 361                                         case 0: item->x = temp; item->f[0] = 1; break;
 362                                         case 1: item->y = temp; item->f[1] = 1; break;
 363                                         case 2: item->w = temp; item->f[2] = 1; break;
 364                                         case 3: item->h = temp; item->f[3] = 1; break;
 365                                         case 4: item->mix = temp; item->f[4] = 1; break;
 366                                 }
 367                         }
 368                         else
 369                         {
 370                                 p ++;
 371                         }
 372
 373                         // Update the value pointer
 374                         value = p;
 375                         count ++;
 376                 }
 377         }
 378         else
 379         {
 380                 ret = 1;
 381         }
 382
 383         return ret;
 384 }
 385
 386 // Fetch a geometry item for an absolute position
 387 int mlt_geometry_fetch( mlt_geometry self, mlt_geometry_item item, float position )
 388 {
 389         // Get the local geometry
 390         geometry g = self->local;
 391
 392         // Need to find the nearest key to the position specifed
 393         geometry_item key = g->item;
 394
 395         // Iterate through the keys until we reach last or have
 396         while( key != NULL && key->next != NULL && position >= key->next->data.frame )
 397                 key = key->next;
 398
 399         if ( key != NULL )
 400         {
 401                 // Position is situated before the first key - all zeroes
 402                 if ( position < key->data.frame )
 403                 {
 404                         memset( item, 0, sizeof( struct mlt_geometry_item_s ) );
 405                         item->mix = 100;
 406                 }
 407                 // Position is a key itself - no iterpolation need
 408                 else if ( position == key->data.frame )
 409                 {
 410                         memcpy( item, &key->data, sizeof( struct mlt_geometry_item_s ) );
 411                 }
 412                 // Position is after the last key - no interpolation, but not a key frame
 413                 else if ( key->next == NULL )
 414                 {
 415                         memcpy( item, &key->data, sizeof( struct mlt_geometry_item_s ) );
 416                         item->key = 0;
 417                         item->f[ 0 ] = 0;
 418                         item->f[ 1 ] = 0;
 419                         item->f[ 2 ] = 0;
 420                         item->f[ 3 ] = 0;
 421                         item->f[ 4 ] = 0;
 422                 }
 423                 // Interpolation is needed - position > key and there is a following key
 424                 else
 425                 {
 426                         item->key = 0;
 427                         item->frame = position;
 428                         position -= key->data.frame;
 429                         item->x = linearstep( key->data.x, key->next->data.x, position, key->next->data.frame - key->data.frame );
 430                         item->y = linearstep( key->data.y, key->next->data.y, position, key->next->data.frame - key->data.frame );
 431                         item->w = linearstep( key->data.w, key->next->data.w, position, key->next->data.frame - key->data.frame );
 432                         item->h = linearstep( key->data.h, key->next->data.h, position, key->next->data.frame - key->data.frame );
 433                         item->mix = linearstep( key->data.mix, key->next->data.mix, position, key->next->data.frame - key->data.frame );
 434                         item->distort = key->data.distort;
 435                         position += key->data.frame;
 436                 }
 437
 438                 item->frame = position;
 439         }
 440         else
 441         {
 442                 memset( item, 0, sizeof( struct mlt_geometry_item_s ) );
 443                 item->frame = position;
 444                 item->mix = 100;
 445         }
 446
 447         return key == NULL;
 448 }
 449
 450 // Specify a geometry item at an absolute position
 451 int mlt_geometry_insert( mlt_geometry self, mlt_geometry_item item )
 452 {
 453         // Get the local/private geometry structure
 454         geometry g = self->local;
 455
 456         // Create a new local item (this may be removed if a key already exists at self position)
 457         geometry_item gi = calloc( 1, sizeof( struct geometry_item_s ) );
 458         memcpy( &gi->data, item, sizeof( struct mlt_geometry_item_s ) );
 459         gi->data.key = 1;
 460
 461         // Determine if we need to insert or append to the list, or if it's a new list
 462         if ( g->item != NULL )
 463         {
 464                 // Get the first item
 465                 geometry_item place = g->item;
 466
 467                 // Locate an existing nearby item
 468                 while ( place->next != NULL && item->frame > place->data.frame )
 469                         place = place->next;
 470
 471                 if ( item->frame < place->data.frame )
 472                 {
 473                         if ( place == g->item )
 474                                 g->item = gi;
 475                         if ( place->prev )
 476                                 place->prev->next = gi;
 477                         gi->next = place;
 478                         gi->prev = place->prev;
 479                         place->prev = gi;
 480                 }
 481                 else if ( item->frame > place->data.frame )
 482                 {
 483                         if ( place->next )
 484                                 place->next->prev = gi;
 485                         gi->next = place->next;
 486                         gi->prev = place;
 487                         place->next = gi;
 488                 }
 489                 else
 490                 {
 491                         memcpy( &place->data, &gi->data, sizeof( struct mlt_geometry_item_s ) );
 492                         free( gi );
 493                 }
 494         }
 495         else
 496         {
 497                 // Set the first item
 498                 g->item = gi;
 499
 500                 // To ensure correct seeding, ensure all values are fixed
 501                 g->item->data.f[0] = 1;
 502                 g->item->data.f[1] = 1;
 503                 g->item->data.f[2] = 1;
 504                 g->item->data.f[3] = 1;
 505                 g->item->data.f[4] = 1;
 506         }
 507
 508         // Refresh all geometries
 509         mlt_geometry_virtual_refresh( self );
 510
 511         // TODO: Error checking
 512         return 0;
 513 }
 514
 515 // Remove the key at the specified position
 516 int mlt_geometry_remove( mlt_geometry self, int position )
 517 {
 518         int ret = 1;
 519
 520         // Get the local/private geometry structure
 521         geometry g = self->local;
 522
 523         // Get the first item
 524         geometry_item place = g->item;
 525
 526         while( place != NULL && position != place->data.frame )
 527                 place = place->next;
 528
 529         if ( place != NULL && position == place->data.frame )
 530                 ret = mlt_geometry_drop( self, place );
 531
 532         // Refresh all geometries
 533         mlt_geometry_virtual_refresh( self );
 534
 535         return ret;
 536 }
 537
 538 // Get the key at the position or the next following
 539 int mlt_geometry_next_key( mlt_geometry self, mlt_geometry_item item, int position )
 540 {
 541         // Get the local/private geometry structure
 542         geometry g = self->local;
 543
 544         // Get the first item
 545         geometry_item place = g->item;
 546
 547         while( place != NULL && position > place->data.frame )
 548                 place = place->next;
 549
 550         if ( place != NULL )
 551                 memcpy( item, &place->data, sizeof( struct mlt_geometry_item_s ) );
 552
 553         return place == NULL;
 554 }
 555
 556 // Get the key at the position or the previous key
 557 int mlt_geometry_prev_key( mlt_geometry self, mlt_geometry_item item, int position )
 558 {
 559         // Get the local/private geometry structure
 560         geometry g = self->local;
 561
 562         // Get the first item
 563         geometry_item place = g->item;
 564
 565         while( place != NULL && place->next != NULL && position >= place->next->data.frame )
 566                 place = place->next;
 567
 568         if ( place != NULL )
 569                 memcpy( item, &place->data, sizeof( struct mlt_geometry_item_s ) );
 570
 571         return place == NULL;
 572 }
 573
 574 #define ISINT(x) ( (x) == (int) (x) )
 575 #define PICKFMT(x) ( ISINT(x) ? "%.0f" : "%f" )
 576
 577 char *mlt_geometry_serialise_cut( mlt_geometry self, int in, int out )
 578 {
 579         geometry g = self->local;
 580         struct mlt_geometry_item_s item;
 581         char *ret = malloc( 1000 );
 582         int used = 0;
 583         int size = 1000;
 584
 585         if ( in == -1 )
 586                 in = 0;
 587         if ( out == -1 )
 588                 out = mlt_geometry_get_length( self );
 589
 590         if ( ret != NULL )
 591         {
 592                 char temp[ 100 ];
 593
 594                 strcpy( ret, "" );
 595
 596                 item.frame = in;
 597
 598                 while( 1 )
 599                 {
 600                         strcpy( temp, "" );
 601
 602                         // If it's the first frame, then it's not necessarily a key
 603                         if ( item.frame == in )
 604                         {
 605                                 if ( mlt_geometry_fetch( self, &item, item.frame ) )
 606                                         break;
 607
 608                                 // If the first key is larger than the current position
 609                                 // then do nothing here
 610                                 if ( g->item->data.frame > item.frame )
 611                                 {
 612                                         item.frame ++;
 613                                         continue;
 614                                 }
 615
 616                                 // To ensure correct seeding, ensure all values are fixed
 617                                 item.f[0] = 1;
 618                                 item.f[1] = 1;
 619                                 item.f[2] = 1;
 620                                 item.f[3] = 1;
 621                                 item.f[4] = 1;
 622                         }
 623                         // Typically, we move from key to key
 624                         else if ( item.frame < out )
 625                         {
 626                                 if ( mlt_geometry_next_key( self, &item, item.frame ) )
 627                                         break;
 628
 629                                 // Special case - crop at the out point
 630                                 if ( item.frame > out )
 631                                         mlt_geometry_fetch( self, &item, out );
 632                         }
 633                         // We've handled the last key
 634                         else
 635                         {
 636                                 break;
 637                         }
 638
 639                         if ( item.frame - in != 0 )
 640                                 sprintf( temp, "%d=", item.frame - in );
 641
 642                         if ( item.f[0] )
 643                                 sprintf( temp + strlen( temp ), PICKFMT( item.x ), item.x );
 644                         if ( item.f[1] ) {
 645                                 strcat( temp, "/" );
 646                                 sprintf( temp + strlen( temp ), PICKFMT( item.y ), item.y );
 647                         }
 648                         if ( item.f[2] ) {
 649                                 strcat( temp, ":" );
 650                                 sprintf( temp + strlen( temp ), PICKFMT( item.w ), item.w );
 651                         }
 652                         if ( item.f[3] ) {
 653                                 strcat( temp, "x" );
 654                                 sprintf( temp + strlen( temp ), PICKFMT( item.h ), item.h );
 655                         }
 656                         if ( item.f[4] ) {
 657                                 strcat( temp, ":" );
 658                                 sprintf( temp + strlen( temp ), PICKFMT( item.mix ), item.mix );
 659                         }
 660
 661                         if ( used + strlen( temp ) > size )
 662                         {
 663                                 size += 1000;
 664                                 ret = realloc( ret, size );
 665                         }
 666
 667                         if ( ret != NULL && used != 0 )
 668                         {
 669                                 used ++;
 670                                 strcat( ret, ";" );
 671                         }
 672                         if ( ret != NULL )
 673                         {
 674                                 used += strlen( temp );
 675                                 strcat( ret, temp );
 676                         }
 677
 678                         item.frame ++;
 679                 }
 680         }
 681
 682         return ret;
 683 }
 684
 685 // Serialise the current geometry
 686 char *mlt_geometry_serialise( mlt_geometry self )
 687 {
 688         geometry g = self->local;
 689         char *ret = mlt_geometry_serialise_cut( self, 0, g->length );
 690         if ( ret )
 691         {
 692                 if ( g->data )
 693                         free( g->data );
 694                 g->data = ret;
 695         }
 696         return ret;
 697 }
 698
 699 // Close the geometry
 700 void mlt_geometry_close( mlt_geometry self )
 701 {
 702         if ( self != NULL )
 703         {
 704                 mlt_geometry_clean( self );
 705                 free( self->local );
 706                 free( self );
 707         }
 708 }
 709
 710