MultiMedia/play/sdlfunc.c

   1 /*
   2    2004/09/10 - Joseph Fenton, added calculation of
   3       samples per frame.
   4 */
   5
   6 #include "externs.h"
   7
   8 static SDL_Surface *screen;
   9 static SDL_Overlay *yuv;
  10 static SDL_Rect rect;
  11
  12 int silence, bytes_in_buffer = 0;
  13
  14 static unsigned char *audioport_buffer = NULL;
  15 static volatile unsigned long samples_played = 0;
  16
  17 extern int use_audio, audio_sample_rate, audio_channels, frame_width, frame_height;
  18
  19 #ifndef min
  20 #define min(a,b) ((a) > (b) ? (b) : (a))
  21 #endif
  22
  23 void os_delay(int msec)
  24 {
  25     SDL_Delay(msec);
  26 }
  27
  28 static unsigned long starttick = 0;
  29
  30 unsigned long get_elapsed_samples(void)
  31 {
  32     if(use_audio)
  33         return samples_played;
  34     else
  35         return (SDL_GetTicks() - starttick);
  36 }
  37
  38 void start_audio(void)
  39 {
  40     if(use_audio)
  41         SDL_PauseAudio(0);
  42 }
  43
  44 void stop_audio(void)
  45 {
  46     if(use_audio)
  47         SDL_PauseAudio(1);
  48 }
  49
  50 int write_audio(char *buffer, int len)
  51 {
  52         if( (bytes_in_buffer+len) <= AUDIOPORT_BUFFERSIZE) {
  53                 SDL_LockAudio();
  54
  55                 memcpy(audioport_buffer+bytes_in_buffer, buffer, len);
  56
  57                 bytes_in_buffer += len;
  58
  59                 SDL_UnlockAudio();
  60
  61                 return len;
  62         }
  63         else if (bytes_in_buffer < AUDIOPORT_BUFFERSIZE) {
  64             // XXX controllare questo codice, non mi convince
  65             fprintf(stderr, "Written in buffer %d bytes, trashed remaining %d bytes\n",
  66                 AUDIOPORT_BUFFERSIZE - bytes_in_buffer,
  67                 len -  (AUDIOPORT_BUFFERSIZE - bytes_in_buffer) );
  68                 SDL_LockAudio();
  69
  70                 memcpy(audioport_buffer+bytes_in_buffer,
  71                 buffer, AUDIOPORT_BUFFERSIZE - bytes_in_buffer);
  72
  73                 bytes_in_buffer = AUDIOPORT_BUFFERSIZE;
  74                 SDL_UnlockAudio();
  75
  76                 return AUDIOPORT_BUFFERSIZE - bytes_in_buffer;
  77         }
  78
  79         fprintf(stderr, "Audio port BUFFER full!!!!\n");
  80
  81         return -1;
  82 }
  83
  84 void my_audio_callback(void *userdata, Uint8 *stream, int len)
  85 {
  86         int amount;
  87
  88         if (bytes_in_buffer > 0) {
  89
  90                 if(bytes_in_buffer>len)
  91                         amount = len;
  92                 else
  93                         amount = bytes_in_buffer;
  94
  95                 SDL_MixAudio(stream, audioport_buffer, amount,
  96                         SDL_MIX_MAXVOLUME);
  97
  98                 samples_played += ((amount/audio_channels)/2);
  99
 100 //              memcpy(stream, audioport_buffer, amount);
 101
 102                 if(amount < bytes_in_buffer) {
 103                         bytes_in_buffer -= amount;
 104                         memcpy(audioport_buffer, audioport_buffer + amount, bytes_in_buffer);
 105                 } else {
 106                     if(amount < len) {
 107                         memset(stream+amount, silence, len - amount);
 108                     }
 109                     bytes_in_buffer = 0;
 110                 }
 111
 112         } else {
 113             memset(stream, silence, len);
 114         }
 115
 116 }
 117
 118 void init_system(char *title)
 119 {
 120     int sdlflags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
 121
 122     if(use_audio)
 123         sdlflags |= SDL_INIT_AUDIO;
 124
 125     if(verbose)
 126         fprintf(stderr, "SDL initialization...\n");
 127
 128     if(debugging)
 129         SDL_Delay(2000);
 130
 131     if(SDL_Init(sdlflags) < 0) {
 132         fprintf(stderr, "Unable to open SDL.");
 133         exit(-1);
 134     }
 135
 136     atexit(SDL_Quit);
 137
 138     if(verbose)
 139         fprintf(stderr, "   Open the window %d,%d\n", frame_width, frame_height);
 140
 141     if(debugging)
 142         SDL_Delay(2000);
 143
 144     if(!(screen = SDL_SetVideoMode(frame_width, frame_height, 0, SDL_RESIZABLE))) {
 145         fprintf(stderr, "Unable to open SDL window: %s.\n", SDL_GetError());
 146         exit(-2);
 147     }
 148
 149     if(verbose)
 150         fprintf(stderr, "   Overlay creation....");
 151
 152     if(debugging)
 153         SDL_Delay(2000);
 154
 155     if ( !(yuv = SDL_CreateYUVOverlay(frame_width, frame_height,
 156                     SDL_YV12_OVERLAY, screen)) ) {
 157                 fprintf(stderr, "Couldn't create overlay: %s\n", SDL_GetError());
 158                 exit(-3);
 159         }
 160
 161         printf("   Created %dx%dx%d %s %s overlay\n",yuv->w,yuv->h,yuv->planes,
 162                         yuv->hw_overlay?"hardware":"software",
 163                         yuv->format==SDL_YV12_OVERLAY?"YV12":
 164                         yuv->format==SDL_IYUV_OVERLAY?"IYUV":
 165                         yuv->format==SDL_YUY2_OVERLAY?"YUY2":
 166                         yuv->format==SDL_UYVY_OVERLAY?"UYVY":
 167                         yuv->format==SDL_YVYU_OVERLAY?"YVYU":
 168                         "Unknown");
 169
 170     if(debugging)
 171         SDL_Delay(2000);
 172
 173     if(use_audio) {
 174         SDL_AudioSpec desired;
 175         unsigned long samples_per_frame;
 176
 177         if(verbose)
 178             fprintf(stderr, "   Opening audio...\n");
 179
 180         if(debugging)
 181             SDL_Delay(2000);
 182
 183         samples_per_frame = (unsigned long) ((double)audio_sample_rate / frame_rate + 0.5);
 184         desired.freq = audio_sample_rate;
 185         desired.channels = audio_channels;
 186         desired.samples = samples_per_frame;
 187
 188 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
 189         desired.format = AUDIO_S16LSB;
 190 #else
 191         desired.format = AUDIO_S16MSB;
 192 #endif
 193
 194         desired.callback = my_audio_callback;
 195
 196         if(SDL_OpenAudio(&desired, NULL) < 0) {
 197             fprintf(stderr, "Unable to open audio: %s.\n", SDL_GetError());
 198             exit(-4);
 199         }
 200
 201         if(debugging)
 202            SDL_Delay(2000);
 203
 204         if(!(audioport_buffer = malloc(AUDIOPORT_BUFFERSIZE))) {
 205             fprintf(stderr, "No memory for the audio buffer!\n");
 206             exit(-5);
 207         }
 208
 209
 210         use_audio = 1;
 211
 212         silence = desired.silence;
 213
 214         SDL_PauseAudio(1);
 215     }
 216
 217     starttick = SDL_GetTicks();
 218
 219     SDL_WM_SetCaption(title, NULL);
 220
 221     rect.x = 0;
 222     rect.y = 0;
 223     rect.w = screen->w;
 224     rect.h = screen->h;
 225
 226     if(debugging)
 227         SDL_Delay(2000);
 228
 229     if(verbose)
 230         fprintf(stderr, "SDL initialized.\n");
 231
 232     if(debugging)
 233         SDL_Delay(2000);
 234 }
 235
 236 void handle_events(void)
 237 {
 238     SDL_Event event;
 239     static int fullscreen = 0;
 240     static int paused = 0;
 241
 242     do {
 243         if(paused)
 244             SDL_WaitEvent(NULL);
 245
 246         while (SDL_PollEvent(&event)) {
 247             switch (event.type) {
 248 #ifdef WIN32
 249                 // per qualche strano motivo win genera questo evento quasi a raffica...
 250                 case 204:
 251                     break;
 252 #endif
 253                 case SDL_MOUSEBUTTONUP:
 254                 case SDL_MOUSEBUTTONDOWN:
 255                     break;
 256                 case SDL_KEYUP:
 257                 case SDL_MOUSEMOTION:
 258                     break;
 259                 case SDL_KEYDOWN:
 260                     switch(event.key.keysym.sym) {
 261                         case SDLK_q:
 262 terminate_app:
 263                             if(benchmark_mode)
 264                                print_benchmark_result();
 265                             else
 266                                fprintf(stderr, "\nTerminated by user request.\n");
 267                             exit(0);
 268                         case SDLK_p:
 269                             paused ^= 1;
 270
 271                             if(paused) {
 272                                 if(verbose)
 273                                     fprintf(stderr, "\nEntering pause mode.\n");
 274                                 stop_audio();
 275                             }
 276                             else {
 277                                 if(verbose)
 278                                     fprintf(stderr, "\nExiting pause mode.\n");
 279                                 start_audio();
 280                             }
 281
 282                             sample_frame = get_elapsed_samples();
 283
 284                             break;
 285                         case SDLK_SPACE:
 286                             SDL_FreeYUVOverlay(yuv);
 287
 288                             rect.x = 0;
 289
 290                             if(fullscreen) {
 291                                 if(verbose)
 292                                     fprintf(stderr, "\nEntering windowed mode...\n");
 293
 294                                 screen = SDL_SetVideoMode(frame_width, frame_height,
 295                                         0 , SDL_RESIZABLE);
 296                                 fullscreen = 0;
 297
 298                                 rect.y = 0;
 299                                 rect.h = screen->h;
 300                             }
 301                             else {
 302                                 if(verbose)
 303                                     fprintf(stderr, "\nEntering fullscreen mode..\n");
 304
 305                                 screen = SDL_SetVideoMode(800, 600,
 306                                         32 , SDL_FULLSCREEN|SDL_SWSURFACE);
 307
 308                                 fullscreen = 1;
 309
 310                                 rect.h = min(screen->h, (screen->w * frame_height)/frame_width);
 311
 312                                 if(rect.h < screen->h) {
 313                                     rect.y = (screen->h - rect.h) / 2;
 314                                 }
 315                             }
 316
 317                             rect.w=screen->w;
 318
 319                             if(!screen) {
 320                                 fprintf(stderr, "Impossible to switch to %s mode.\n",
 321                                         fullscreen ? "fullscreen" : "windowed");
 322                                 exit(0);
 323                             }
 324
 325                             if(!(yuv = SDL_CreateYUVOverlay(frame_width, frame_height,
 326                                             SDL_YV12_OVERLAY, screen))) {
 327                                 fprintf(stderr,  "Impossible to recreate video overlay!\n");
 328                                 exit(0);
 329                             }
 330
 331                             if(verbose)
 332                                 fprintf(stderr, "Setting rectangle to (%d,%d) %dx%d\n",
 333                                         rect.x, rect.y, rect.w, rect.h);
 334                             break;
 335                     }
 336                     break;
 337                 case SDL_QUIT:
 338                     goto terminate_app;
 339
 340                 case SDL_VIDEORESIZE:
 341                     SDL_FreeYUVOverlay(yuv);
 342
 343                     screen=SDL_SetVideoMode(event.resize.w, event.resize.h,
 344                             0 , SDL_RESIZABLE);
 345
 346                     if(!screen) {
 347                         fprintf(stderr, "Non riesco a ridimensionare la finestra!\n");
 348                         return;
 349                     }
 350
 351                     if(!(yuv = SDL_CreateYUVOverlay(frame_width, frame_height,
 352                                     SDL_YV12_OVERLAY, screen))) {
 353                         fprintf(stderr,  "Errore nell'inizializzazione dell'overlay!\n");
 354                         return;
 355                     }
 356
 357                     rect.w=event.resize.w;
 358                     rect.h=event.resize.h;
 359                     break;
 360             }
 361         }
 362     } while(paused);
 363
 364     return;
 365 }
 366
 367 void display_picture(AVPicture *picture)
 368 {
 369     if(yuv && !SDL_LockYUVOverlay(yuv) ) {
 370
 371         if(yuv->pitches[0] == picture->linesize[0]) {
 372             int size = yuv->pitches[0] * yuv->h;
 373
 374             memcpy(yuv->pixels[0], picture->data[0], size);
 375             size /= 4;
 376             memcpy(yuv->pixels[2], picture->data[1], size);
 377             memcpy(yuv->pixels[1], picture->data[2], size);
 378         }
 379         else {
 380             register unsigned char *y1,*y2,*y3,*i1,*i2,*i3;
 381             int i;
 382             y1 = yuv->pixels[0];
 383             y3 = yuv->pixels[1]; // invertiti xche' avevo i colori sballati!
 384             y2 = yuv->pixels[2];
 385
 386             i1=picture->data[0];
 387             i2=picture->data[1];
 388             i3=picture->data[2];
 389
 390             for (i = 0; i<(yuv->h/2); i++) {
 391                 memcpy(y1,i1,yuv->pitches[0]);
 392                 i1+=picture->linesize[0];
 393                 y1+=yuv->pitches[0];
 394                 memcpy(y1,i1,yuv->pitches[0]);
 395
 396                 memcpy(y2,i2,yuv->pitches[1]);
 397                 memcpy(y3,i3,yuv->pitches[2]);
 398
 399                 y1+=yuv->pitches[0];
 400                 y2+=yuv->pitches[1];
 401                 y3+=yuv->pitches[2];
 402                 i1+=picture->linesize[0];
 403                 i2+=picture->linesize[1];
 404                 i3+=picture->linesize[2];
 405             }
 406         }
 407         SDL_UnlockYUVOverlay(yuv);
 408     }
 409
 410     SDL_DisplayYUVOverlay(yuv, &rect);
 411 }
 412