👨🏽‍🎓 🚚 👩🏽‍🌾 [भाग 2/2] FFmpeg और SDL के लिए गाइड या 1000 लाइनों से कम में वीडियो प्लेयर कैसे लिखें 🐶 ➡️ 👨‍🔬

हम शेष अनुवाद को मैनुअल के रूसी में पोस्ट करते हैं, जो कुछ हद तक पुराना है, लेकिन इसकी प्रासंगिकता नहीं खोई है, क्योंकि यह ट्यूटोरियल FFmpeg और SDL पुस्तकालयों का उपयोग करके वीडियो एप्लिकेशन बनाने के "रसोई" को समझने में मदद करता है।

और यद्यपि हमने कोशिश की, इस तरह के एक चमकदार पाठ में अनुवाद की कठिनाइयाँ अपरिहार्य हैं । बग्स की रिपोर्ट करें (अधिमानतः निजी संदेशों में) - एक साथ हम बेहतर करेंगे।

विषय - सूची

भाग 1	भाग 2
प्रस्तावना पाठ 1: स्क्रेन्सैप्स पाठ 2 बनाना : पाठ 3 दिखाना: ध्वनि पाठ 4 बजाना : कई सूत्र पाठ 5: वीडियो सिंक्रनाइज़ करना	पाठ 6: ऑडियो सिंक्रनाइज़ेशन पाठ 7: खोज के बाद परिशिष्ट 1. कार्यों की सूची परिशिष्ट 2. डेटा संरचनाएं लिंक

EDISON.

, .

, , Axxon Next SureView Immix.

! ;-)

6: ← ⇑ →

tutorial06.c

// tutorial05.c
// A pedagogical video player that really works!
//
// Code based on FFplay, Copyright (c) 2003 Fabrice Bellard, 
// and a tutorial by Martin Bohme (boehme@inb.uni-luebeckREMOVETHIS.de)
// Tested on Gentoo, CVS version 5/01/07 compiled with GCC 4.1.1
// With updates from https://github.com/chelyaev/ffmpeg-tutorial
// Updates tested on:
// LAVC 54.59.100, LAVF 54.29.104, LSWS 2.1.101, SDL 1.2.15
// on GCC 4.7.2 in Debian February 2015
// Use
//
// gcc -o tutorial05 tutorial05.c -lavformat -lavcodec -lswscale -lz -lm `sdl-config --cflags --libs`
// to build (assuming libavformat and libavcodec are correctly installed, 
// and assuming you have sdl-config. Please refer to SDL docs for your installation.)
//
// Run using
// tutorial04 myvideofile.mpg
//
// to play the video stream on your screen.

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#include <SDL.h>
#include <SDL_thread.h>

#ifdef __MINGW32__
#undef main /* Prevents SDL from overriding main() */
#endif

#include <stdio.h>
#include <assert.h>
#include <math.h>

// compatibility with newer API
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
#define av_frame_alloc avcodec_alloc_frame
#define av_frame_free avcodec_free_frame
#endif

#define SDL_AUDIO_BUFFER_SIZE 1024
#define MAX_AUDIO_FRAME_SIZE 192000

#define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
#define MAX_VIDEOQ_SIZE (5 * 256 * 1024)

#define AV_SYNC_THRESHOLD 0.01
#define AV_NOSYNC_THRESHOLD 10.0

#define SAMPLE_CORRECTION_PERCENT_MAX 10
#define AUDIO_DIFF_AVG_NB 20

#define FF_REFRESH_EVENT (SDL_USEREVENT)
#define FF_QUIT_EVENT (SDL_USEREVENT + 1)

#define VIDEO_PICTURE_QUEUE_SIZE 1

#define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER

typedef struct PacketQueue {
  AVPacketList *first_pkt, *last_pkt;
  int nb_packets;
  int size;
  SDL_mutex *mutex;
  SDL_cond *cond;
} PacketQueue;


typedef struct VideoPicture {
  SDL_Overlay *bmp;
  int width, height; /* source height & width */
  int allocated;
  double pts;
} VideoPicture;

typedef struct VideoState {

  AVFormatContext *pFormatCtx;
  int             videoStream, audioStream;

  int             av_sync_type;
  double          external_clock; /* external clock base */
  int64_t         external_clock_time;

  double          audio_clock;
  AVStream        *audio_st;
  AVCodecContext  *audio_ctx;
  PacketQueue     audioq;
  uint8_t         audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];
  unsigned int    audio_buf_size;
  unsigned int    audio_buf_index;
  AVFrame         audio_frame;
  AVPacket        audio_pkt;
  uint8_t         *audio_pkt_data;
  int             audio_pkt_size;
  int             audio_hw_buf_size;
  double          audio_diff_cum; /* used for AV difference average computation */
  double          audio_diff_avg_coef;
  double          audio_diff_threshold;
  int             audio_diff_avg_count;
  double          frame_timer;
  double          frame_last_pts;
  double          frame_last_delay;
  double          video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame
  double          video_current_pts; ///<current displayed pts (different from video_clock if frame fifos are used)
  int64_t         video_current_pts_time;  ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
  AVStream        *video_st;
  AVCodecContext  *video_ctx;
  PacketQueue     videoq;
  struct SwsContext *sws_ctx;

  VideoPicture    pictq[VIDEO_PICTURE_QUEUE_SIZE];
  int             pictq_size, pictq_rindex, pictq_windex;
  SDL_mutex       *pictq_mutex;
  SDL_cond        *pictq_cond;
  
  SDL_Thread      *parse_tid;
  SDL_Thread      *video_tid;

  char            filename[1024];
  int             quit;
} VideoState;

enum {
  AV_SYNC_AUDIO_MASTER,
  AV_SYNC_VIDEO_MASTER,
  AV_SYNC_EXTERNAL_MASTER,
};

SDL_Surface     *screen;
SDL_mutex       *screen_mutex;

/* Since we only have one decoding thread, the Big Struct
   can be global in case we need it. */
VideoState *global_video_state;

void packet_queue_init(PacketQueue *q) {
  memset(q, 0, sizeof(PacketQueue));
  q->mutex = SDL_CreateMutex();
  q->cond = SDL_CreateCond();
}
int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

  AVPacketList *pkt1;
  if(av_dup_packet(pkt) < 0) {
    return -1;
  }
  pkt1 = av_malloc(sizeof(AVPacketList));
  if (!pkt1)
    return -1;
  pkt1->pkt = *pkt;
  pkt1->next = NULL;
  
  SDL_LockMutex(q->mutex);

  if (!q->last_pkt)
    q->first_pkt = pkt1;
  else
    q->last_pkt->next = pkt1;
  q->last_pkt = pkt1;
  q->nb_packets++;
  q->size += pkt1->pkt.size;
  SDL_CondSignal(q->cond);
  
  SDL_UnlockMutex(q->mutex);
  return 0;
}
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
{
  AVPacketList *pkt1;
  int ret;

  SDL_LockMutex(q->mutex);
  
  for(;;) {
    
    if(global_video_state->quit) {
      ret = -1;
      break;
    }

    pkt1 = q->first_pkt;
    if (pkt1) {
      q->first_pkt = pkt1->next;
      if (!q->first_pkt)
	q->last_pkt = NULL;
      q->nb_packets--;
      q->size -= pkt1->pkt.size;
      *pkt = pkt1->pkt;
      av_free(pkt1);
      ret = 1;
      break;
    } else if (!block) {
      ret = 0;
      break;
    } else {
      SDL_CondWait(q->cond, q->mutex);
    }
  }
  SDL_UnlockMutex(q->mutex);
  return ret;
}

double get_audio_clock(VideoState *is) {
  double pts;
  int hw_buf_size, bytes_per_sec, n;
  
  pts = is->audio_clock; /* maintained in the audio thread */
  hw_buf_size = is->audio_buf_size - is->audio_buf_index;
  bytes_per_sec = 0;
  n = is->audio_ctx->channels * 2;
  if(is->audio_st) {
    bytes_per_sec = is->audio_ctx->sample_rate * n;
  }
  if(bytes_per_sec) {
    pts -= (double)hw_buf_size / bytes_per_sec;
  }
  return pts;
}
double get_video_clock(VideoState *is) {
  double delta;

  delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
  return is->video_current_pts + delta;
}
double get_external_clock(VideoState *is) {
  return av_gettime() / 1000000.0;
}

double get_master_clock(VideoState *is) {
  if(is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
    return get_video_clock(is);
  } else if(is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
    return get_audio_clock(is);
  } else {
    return get_external_clock(is);
  }
}


/* Add or subtract samples to get a better sync, return new
   audio buffer size */
int synchronize_audio(VideoState *is, short *samples,
		      int samples_size, double pts) {
  int n;
  double ref_clock;

  n = 2 * is->audio_ctx->channels;
  
  if(is->av_sync_type != AV_SYNC_AUDIO_MASTER) {
    double diff, avg_diff;
    int wanted_size, min_size, max_size /*, nb_samples */;
    
    ref_clock = get_master_clock(is);
    diff = get_audio_clock(is) - ref_clock;

    if(diff < AV_NOSYNC_THRESHOLD) {
      // accumulate the diffs
      is->audio_diff_cum = diff + is->audio_diff_avg_coef
	* is->audio_diff_cum;
      if(is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
	is->audio_diff_avg_count++;
      } else {
	avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
	if(fabs(avg_diff) >= is->audio_diff_threshold) {
	  wanted_size = samples_size + ((int)(diff * is->audio_ctx->sample_rate) * n);
	  min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100);
	  max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100);
	  if(wanted_size < min_size) {
	    wanted_size = min_size;
	  } else if (wanted_size > max_size) {
	    wanted_size = max_size;
	  }
	  if(wanted_size < samples_size) {
	    /* remove samples */
	    samples_size = wanted_size;
	  } else if(wanted_size > samples_size) {
	    uint8_t *samples_end, *q;
	    int nb;

	    /* add samples by copying final sample*/
	    nb = (samples_size - wanted_size);
	    samples_end = (uint8_t *)samples + samples_size - n;
	    q = samples_end + n;
	    while(nb > 0) {
	      memcpy(q, samples_end, n);
	      q += n;
	      nb -= n;
	    }
	    samples_size = wanted_size;
	  }
	}
      }
    } else {
      /* difference is TOO big; reset diff stuff */
      is->audio_diff_avg_count = 0;
      is->audio_diff_cum = 0;
    }
  }
  return samples_size;
}

int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr) {

  int len1, data_size = 0;
  AVPacket *pkt = &is->audio_pkt;
  double pts;
  int n;

  for(;;) {
    while(is->audio_pkt_size > 0) {
      int got_frame = 0;
      len1 = avcodec_decode_audio4(is->audio_ctx, &is->audio_frame, &got_frame, pkt);
      if(len1 < 0) {
	/* if error, skip frame */
	is->audio_pkt_size = 0;
	break;
      }
      data_size = 0;
      if(got_frame) {
	data_size = av_samples_get_buffer_size(NULL, 
					       is->audio_ctx->channels,
					       is->audio_frame.nb_samples,
					       is->audio_ctx->sample_fmt,
					       1);
	assert(data_size <= buf_size);
	memcpy(audio_buf, is->audio_frame.data[0], data_size);
      }
      is->audio_pkt_data += len1;
      is->audio_pkt_size -= len1;
      if(data_size <= 0) {
	/* No data yet, get more frames */
	continue;
      }
      pts = is->audio_clock;
      *pts_ptr = pts;
      n = 2 * is->audio_ctx->channels;
      is->audio_clock += (double)data_size /
	(double)(n * is->audio_ctx->sample_rate);
      /* We have data, return it and come back for more later */
      return data_size;
    }
    if(pkt->data)
      av_free_packet(pkt);

    if(is->quit) {
      return -1;
    }
    /* next packet */
    if(packet_queue_get(&is->audioq, pkt, 1) < 0) {
      return -1;
    }
    is->audio_pkt_data = pkt->data;
    is->audio_pkt_size = pkt->size;
    /* if update, update the audio clock w/pts */
    if(pkt->pts != AV_NOPTS_VALUE) {
      is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
    }
  }
}

void audio_callback(void *userdata, Uint8 *stream, int len) {

  VideoState *is = (VideoState *)userdata;
  int len1, audio_size;
  double pts;

  while(len > 0) {
    if(is->audio_buf_index >= is->audio_buf_size) {
      /* We have already sent all our data; get more */
      audio_size = audio_decode_frame(is, is->audio_buf, sizeof(is->audio_buf), &pts);
      if(audio_size < 0) {
	/* If error, output silence */
	is->audio_buf_size = 1024;
	memset(is->audio_buf, 0, is->audio_buf_size);
      } else {
	audio_size = synchronize_audio(is, (int16_t *)is->audio_buf,
				       audio_size, pts);
	is->audio_buf_size = audio_size;
      }
      is->audio_buf_index = 0;
    }
    len1 = is->audio_buf_size - is->audio_buf_index;
    if(len1 > len)
      len1 = len;
    memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
    len -= len1;
    stream += len1;
    is->audio_buf_index += len1;
  }
}

static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {
  SDL_Event event;
  event.type = FF_REFRESH_EVENT;
  event.user.data1 = opaque;
  SDL_PushEvent(&event);
  return 0; /* 0 means stop timer */
}

/* schedule a video refresh in 'delay' ms */
static void schedule_refresh(VideoState *is, int delay) {
  SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
}

void video_display(VideoState *is) {

  SDL_Rect rect;
  VideoPicture *vp;
  float aspect_ratio;
  int w, h, x, y;
  int i;

  vp = &is->pictq[is->pictq_rindex];
  if(vp->bmp) {
    if(is->video_ctx->sample_aspect_ratio.num == 0) {
      aspect_ratio = 0;
    } else {
      aspect_ratio = av_q2d(is->video_ctx->sample_aspect_ratio) *
	is->video_ctx->width / is->video_ctx->height;
    }
    if(aspect_ratio <= 0.0) {
      aspect_ratio = (float)is->video_ctx->width /
	(float)is->video_ctx->height;
    }
    h = screen->h;
    w = ((int)rint(h * aspect_ratio)) & -3;
    if(w > screen->w) {
      w = screen->w;
      h = ((int)rint(w / aspect_ratio)) & -3;
    }
    x = (screen->w - w) / 2;
    y = (screen->h - h) / 2;
    
    rect.x = x;
    rect.y = y;
    rect.w = w;
    rect.h = h;
    SDL_LockMutex(screen_mutex);
    SDL_DisplayYUVOverlay(vp->bmp, &rect);
    SDL_UnlockMutex(screen_mutex);
  }
}

void video_refresh_timer(void *userdata) {

  VideoState *is = (VideoState *)userdata;
  VideoPicture *vp;
  double actual_delay, delay, sync_threshold, ref_clock, diff;
  
  if(is->video_st) {
    if(is->pictq_size == 0) {
      schedule_refresh(is, 1);
    } else {
      vp = &is->pictq[is->pictq_rindex];
      
      is->video_current_pts = vp->pts;
      is->video_current_pts_time = av_gettime();
      delay = vp->pts - is->frame_last_pts; /* the pts from last time */
      if(delay <= 0 || delay >= 1.0) {
	/* if incorrect delay, use previous one */
	delay = is->frame_last_delay;
      }
      /* save for next time */
      is->frame_last_delay = delay;
      is->frame_last_pts = vp->pts;



      /* update delay to sync to audio if not master source */
      if(is->av_sync_type != AV_SYNC_VIDEO_MASTER) {
	ref_clock = get_master_clock(is);
	diff = vp->pts - ref_clock;
	
	/* Skip or repeat the frame. Take delay into account
	   FFPlay still doesn't "know if this is the best guess." */
	sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;
	if(fabs(diff) < AV_NOSYNC_THRESHOLD) {
	  if(diff <= -sync_threshold) {
	    delay = 0;
	  } else if(diff >= sync_threshold) {
	    delay = 2 * delay;
	  }
	}
      }
      is->frame_timer += delay;
      /* computer the REAL delay */
      actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
      if(actual_delay < 0.010) {
	/* Really it should skip the picture instead */
	actual_delay = 0.010;
      }
      schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));
      
      /* show the picture! */
      video_display(is);
      
      /* update queue for next picture! */
      if(++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {
	is->pictq_rindex = 0;
      }
      SDL_LockMutex(is->pictq_mutex);
      is->pictq_size--;
      SDL_CondSignal(is->pictq_cond);
      SDL_UnlockMutex(is->pictq_mutex);
    }
  } else {
    schedule_refresh(is, 100);
  }
}
      
void alloc_picture(void *userdata) {

  VideoState *is = (VideoState *)userdata;
  VideoPicture *vp;

  vp = &is->pictq[is->pictq_windex];
  if(vp->bmp) {
    // we already have one make another, bigger/smaller
    SDL_FreeYUVOverlay(vp->bmp);
  }
  // Allocate a place to put our YUV image on that screen
  SDL_LockMutex(screen_mutex);
  vp->bmp = SDL_CreateYUVOverlay(is->video_ctx->width,
				 is->video_ctx->height,
				 SDL_YV12_OVERLAY,
				 screen);
  SDL_UnlockMutex(screen_mutex);

  vp->width = is->video_ctx->width;
  vp->height = is->video_ctx->height;
  vp->allocated = 1;

}

int queue_picture(VideoState *is, AVFrame *pFrame, double pts) {

  VideoPicture *vp;
  int dst_pix_fmt;
  AVPicture pict;

  /* wait until we have space for a new pic */
  SDL_LockMutex(is->pictq_mutex);
  while(is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
	!is->quit) {
    SDL_CondWait(is->pictq_cond, is->pictq_mutex);
  }
  SDL_UnlockMutex(is->pictq_mutex);

  if(is->quit)
    return -1;

  // windex is set to 0 initially
  vp = &is->pictq[is->pictq_windex];

  /* allocate or resize the buffer! */
  if(!vp->bmp ||
     vp->width != is->video_ctx->width ||
     vp->height != is->video_ctx->height) {
    SDL_Event event;

    vp->allocated = 0;
    alloc_picture(is);
    if(is->quit) {
      return -1;
    }
  }

  /* We have a place to put our picture on the queue */

  if(vp->bmp) {

    SDL_LockYUVOverlay(vp->bmp);
    vp->pts = pts;
    
    dst_pix_fmt = PIX_FMT_YUV420P;
    /* point pict at the queue */

    pict.data[0] = vp->bmp->pixels[0];
    pict.data[1] = vp->bmp->pixels[2];
    pict.data[2] = vp->bmp->pixels[1];
    
    pict.linesize[0] = vp->bmp->pitches[0];
    pict.linesize[1] = vp->bmp->pitches[2];
    pict.linesize[2] = vp->bmp->pitches[1];
    
    // Convert the image into YUV format that SDL uses
    sws_scale(is->sws_ctx, (uint8_t const * const *)pFrame->data,
	      pFrame->linesize, 0, is->video_ctx->height,
	      pict.data, pict.linesize);
    
    SDL_UnlockYUVOverlay(vp->bmp);
    /* now we inform our display thread that we have a pic ready */
    if(++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {
      is->pictq_windex = 0;
    }
    SDL_LockMutex(is->pictq_mutex);
    is->pictq_size++;
    SDL_UnlockMutex(is->pictq_mutex);
  }
  return 0;
}

double synchronize_video(VideoState *is, AVFrame *src_frame, double pts) {

  double frame_delay;

  if(pts != 0) {
    /* if we have pts, set video clock to it */
    is->video_clock = pts;
  } else {
    /* if we aren't given a pts, set it to the clock */
    pts = is->video_clock;
  }
  /* update the video clock */
  frame_delay = av_q2d(is->video_ctx->time_base);
  /* if we are repeating a frame, adjust clock accordingly */
  frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
  is->video_clock += frame_delay;
  return pts;
}

int video_thread(void *arg) {
  VideoState *is = (VideoState *)arg;
  AVPacket pkt1, *packet = &pkt1;
  int frameFinished;
  AVFrame *pFrame;
  double pts;

  pFrame = av_frame_alloc();

  for(;;) {
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    pts = 0;

    // Decode video frame
    avcodec_decode_video2(is->video_ctx, pFrame, &frameFinished, packet);

    if((pts = av_frame_get_best_effort_timestamp(pFrame)) == AV_NOPTS_VALUE) {
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_st->time_base);

    // Did we get a video frame?
    if(frameFinished) {
      pts = synchronize_video(is, pFrame, pts);
      if(queue_picture(is, pFrame, pts) < 0) {
	break;
      }
    }
    av_free_packet(packet);
  }
  av_frame_free(&pFrame);
  return 0;
}

int stream_component_open(VideoState *is, int stream_index) {

  AVFormatContext *pFormatCtx = is->pFormatCtx;
  AVCodecContext *codecCtx = NULL;
  AVCodec *codec = NULL;
  SDL_AudioSpec wanted_spec, spec;

  if(stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
    return -1;
  }

  codec = avcodec_find_decoder(pFormatCtx->streams[stream_index]->codec->codec_id);
  if(!codec) {
    fprintf(stderr, "Unsupported codec!\n");
    return -1;
  }

  codecCtx = avcodec_alloc_context3(codec);
  if(avcodec_copy_context(codecCtx, pFormatCtx->streams[stream_index]->codec) != 0) {
    fprintf(stderr, "Couldn't copy codec context");
    return -1; // Error copying codec context
  }


  if(codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
    // Set audio settings from codec info
    wanted_spec.freq = codecCtx->sample_rate;
    wanted_spec.format = AUDIO_S16SYS;
    wanted_spec.channels = codecCtx->channels;
    wanted_spec.silence = 0;
    wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
    wanted_spec.callback = audio_callback;
    wanted_spec.userdata = is;
    
    if(SDL_OpenAudio(&wanted_spec, &spec) < 0) {
      fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
      return -1;
    }
    is->audio_hw_buf_size = spec.size;
  }
  if(avcodec_open2(codecCtx, codec, NULL) < 0) {
    fprintf(stderr, "Unsupported codec!\n");
    return -1;
  }

  switch(codecCtx->codec_type) {
  case AVMEDIA_TYPE_AUDIO:
    is->audioStream = stream_index;
    is->audio_st = pFormatCtx->streams[stream_index];
    is->audio_ctx = codecCtx;
    is->audio_buf_size = 0;
    is->audio_buf_index = 0;
    memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
    packet_queue_init(&is->audioq);
    SDL_PauseAudio(0);
    break;
  case AVMEDIA_TYPE_VIDEO:
    is->videoStream = stream_index;
    is->video_st = pFormatCtx->streams[stream_index];
    is->video_ctx = codecCtx;

    is->frame_timer = (double)av_gettime() / 1000000.0;
    is->frame_last_delay = 40e-3;
    is->video_current_pts_time = av_gettime();

    packet_queue_init(&is->videoq);
    is->video_tid = SDL_CreateThread(video_thread, is);
    is->sws_ctx = sws_getContext(is->video_ctx->width, is->video_ctx->height,
				 is->video_ctx->pix_fmt, is->video_ctx->width,
				 is->video_ctx->height, PIX_FMT_YUV420P,
				 SWS_BILINEAR, NULL, NULL, NULL
				 );
    break;
  default:
    break;
  }
}

int decode_thread(void *arg) {

  VideoState *is = (VideoState *)arg;
  AVFormatContext *pFormatCtx;
  AVPacket pkt1, *packet = &pkt1;

  int video_index = -1;
  int audio_index = -1;
  int i;

  is->videoStream=-1;
  is->audioStream=-1;

  global_video_state = is;

  // Open video file
  if(avformat_open_input(&pFormatCtx, is->filename, NULL, NULL)!=0)
    return -1; // Couldn't open file

  is->pFormatCtx = pFormatCtx;
  
  // Retrieve stream information
  if(avformat_find_stream_info(pFormatCtx, NULL)<0)
    return -1; // Couldn't find stream information
  
  // Dump information about file onto standard error
  av_dump_format(pFormatCtx, 0, is->filename, 0);
  
  // Find the first video stream

  for(i=0; i<pFormatCtx->nb_streams; i++) {
    if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO &&
       video_index < 0) {
      video_index=i;
    }
    if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO &&
       audio_index < 0) {
      audio_index=i;
    }
  }
  if(audio_index >= 0) {
    stream_component_open(is, audio_index);
  }
  if(video_index >= 0) {
    stream_component_open(is, video_index);
  }   

  if(is->videoStream < 0 || is->audioStream < 0) {
    fprintf(stderr, "%s: could not open codecs\n", is->filename);
    goto fail;
  }

  // main decode loop

  for(;;) {
    if(is->quit) {
      break;
    }
    // seek stuff goes here
    if(is->audioq.size > MAX_AUDIOQ_SIZE ||
       is->videoq.size > MAX_VIDEOQ_SIZE) {
      SDL_Delay(10);
      continue;
    }
    if(av_read_frame(is->pFormatCtx, packet) < 0) {
      if(is->pFormatCtx->pb->error == 0) {
	SDL_Delay(100); /* no error; wait for user input */
	continue;
      } else {
	break;
      }
    }
    // Is this a packet from the video stream?
    if(packet->stream_index == is->videoStream) {
      packet_queue_put(&is->videoq, packet);
    } else if(packet->stream_index == is->audioStream) {
      packet_queue_put(&is->audioq, packet);
    } else {
      av_free_packet(packet);
    }
  }
  /* all done - wait for it */
  while(!is->quit) {
    SDL_Delay(100);
  }

 fail:
  if(1){
    SDL_Event event;
    event.type = FF_QUIT_EVENT;
    event.user.data1 = is;
    SDL_PushEvent(&event);
  }
  return 0;
}

int main(int argc, char *argv[]) {

  SDL_Event       event;

  VideoState      *is;

  is = av_mallocz(sizeof(VideoState));

  if(argc < 2) {
    fprintf(stderr, "Usage: test <file>\n");
    exit(1);
  }
  // Register all formats and codecs
  av_register_all();
  
  if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
    fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
    exit(1);
  }

  // Make a screen to put our video
#ifndef __DARWIN__
        screen = SDL_SetVideoMode(640, 480, 0, 0);
#else
        screen = SDL_SetVideoMode(640, 480, 24, 0);
#endif
  if(!screen) {
    fprintf(stderr, "SDL: could not set video mode - exiting\n");
    exit(1);
  }

  screen_mutex = SDL_CreateMutex();

  av_strlcpy(is->filename, argv[1], sizeof(is->filename));

  is->pictq_mutex = SDL_CreateMutex();
  is->pictq_cond = SDL_CreateCond();

  schedule_refresh(is, 40);

  is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
  is->parse_tid = SDL_CreateThread(decode_thread, is);
  if(!is->parse_tid) {
    av_free(is);
    return -1;
  }
  for(;;) {

    SDL_WaitEvent(&event);
    switch(event.type) {
    case FF_QUIT_EVENT:
    case SDL_QUIT:
      is->quit = 1;
      SDL_Quit();
      return 0;
      break;
    case FF_REFRESH_EVENT:
      video_refresh_timer(event.user.data1);
      break;
    default:
      break;
    }
  }
  return 0;
}

अब जब हमारे पास कम या ज्यादा सभ्य खिलाड़ी है, जिस पर आप फिल्म देख सकते हैं, तो चलिए अब मिलते हैं। पिछली बार, हमने थोड़ी देर में सिंक्रनाइज़ेशन, अर्थात् वीडियो के साथ ध्वनि के सिंक्रनाइज़ेशन को छुआ, उस क्रम में, इसके विपरीत नहीं। हम इसे वीडियो के समान लेआउट बनाने जा रहे हैं: वीडियो स्ट्रीम को ट्रैक करने के लिए एक आंतरिक वीडियो घड़ी बनाएं और ऑडियो को इसके साथ सिंक्रनाइज़ करें। बाद में हम और भी अधिक सामान्यीकरण करेंगे - हम एक बाहरी घड़ी के साथ ऑडियो और वीडियो को सिंक्रनाइज़ करते हैं।

वीडियो घड़ी कार्यान्वयन

अब हम आखिरी बार हमारे पास मौजूद ऑडियो घड़ी के समान एक वीडियो घड़ी बनाना चाहते हैं: एक आंतरिक मूल्य जो वर्तमान में खेल रहे वीडियो के वर्तमान समय की भरपाई करता है। आप सोच सकते हैं कि यह अंतिम फ्रेम के वर्तमान पीटीएस के साथ टाइमर को अपडेट करने जितना सरल होगा । हालांकि, यह मत भूलो कि वीडियो फ्रेम के बीच का समय बहुत लंबा हो सकता है अगर हम मिलीसेकंड स्तर तक गिरते हैं। इसलिए, समाधान एक और मूल्य को ट्रैक करना है, जिस समय हम आखिरी फ्रेम के पीटीएस पर वीडियो घड़ी सेट करते हैं । इस प्रकार, वीडियो घड़ी का वर्तमान मूल्य PTS_of_last_frame + ( current_time - time_elapsed_since_PTS_value_was_set) होगा) यह समाधान बहुत कुछ वैसा ही है जैसा हमने get_audio_clock के साथ किया था ।

तो, हमारी पूर्ण विकसित संरचना में हम डबल वीडियो_क्रंट_इप्स और इंटि_64 वीडियो टी_क्रांति_प्रेश_टाइम डालने जा रहे हैं । घड़ी को video_refresh_timer फ़ंक्शन में अपडेट किया जाएगा :

void video_refresh_timer(void *userdata) {

  /* ... */

  if(is->video_st) {
    if(is->pictq_size == 0) {
      schedule_refresh(is, 1);
    } else {
      vp = &is->pictq[is->pictq_rindex];

      is->video_current_pts = vp->pts;
      is->video_current_pts_time = av_gettime();

इसे initial_component_open में इनिशियलाइज़ करना न भूलें :

is->video_current_pts_time = av_gettime();

और अब हम सभी को जानकारी प्राप्त करने का कोई तरीका चाहिए:

double get_video_clock(VideoState *is) {
  double delta;

  delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
  return is->video_current_pts + delta;
}

घड़ी से सार

लेकिन एक वीडियो घड़ी का उपयोग करने के लिए अपने आप को क्यों मजबूर करें? आप आगे जा सकते हैं और हमारे वीडियो सिंक्रनाइज़ेशन कोड को बदल सकते हैं ताकि ऑडियो और वीडियो एक दूसरे को सिंक्रनाइज़ करने का प्रयास न करें। कल्पना कीजिए कि अगर हम कमांड लाइन विकल्प के साथ ऐसा करने की कोशिश करेंगे, तो जैसा कि FFplay में है। तो, चलिए अमूर्त करते हैं: हम एक नया आवरण फ़ंक्शन बनाएंगे , get_master_clock , जो चर av_sync_type की जांच करता है , और फिर get_audio_clock , get_video_clock , या किसी अन्य घड़ी को कॉल कर सकता है जो इसका उपयोग कर सकती है। हम एक कंप्यूटर घड़ी का उपयोग भी कर सकते हैं, जिसे हम get_external_clock कहते हैं :

enum {
  AV_SYNC_AUDIO_MASTER,
  AV_SYNC_VIDEO_MASTER,
  AV_SYNC_EXTERNAL_MASTER,
};

#define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER

double get_master_clock(VideoState *is) {
  if(is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
    return get_video_clock(is);
  } else if(is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
    return get_audio_clock(is);
  } else {
    return get_external_clock(is);
  }
}
main() {
...
  is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
...
}

ऑडियो सिंक

अब सबसे कठिन भाग: वीडियो घड़ी के साथ ऑडियो को सिंक्रनाइज़ करना। हमारी रणनीति यह मापना है कि ऑडियो कहां है, इसकी तुलना वीडियो घड़ी से करें, और फिर पता लगाएं कि हमें कितने नमूनों को समायोजित करने की आवश्यकता है, यानी, हमें नमूनों को छोड़ने या जोड़कर धीमा करने की आवश्यकता है? जब भी हम इस सेट को ठीक से कम करने या बढ़ाने के लिए प्राप्त करते हैं, तो हम हर बार सिंक्रोनाइज़_ऑडियो

फ़ंक्शन को चलाते हैं । हालाँकि, हम हर समय सिंक्रनाइज़ नहीं करना चाहते हैं, क्योंकि ऑडियो प्रसंस्करण वीडियो पैकेट के प्रसंस्करण की तुलना में बहुत अधिक बार होता है। इसलिए, हम सिंक्रोनाइज़_ऑडियो फ़ंक्शन के लिए लगातार कॉल की न्यूनतम संख्या सेट करने जा रहे हैंइससे पहले कि हम कुछ भी करने की जहमत उठाएं, उसे अनसंकटेड माना जाए। बेशक, पिछली बार के रूप में, "अनसिंक्रनाइज़ेशन" का मतलब है कि ऑडियो घड़ी और वीडियो घड़ी सिंक्रोनाइज़ थ्रेशोल्ड से अधिक राशि से भिन्न होती है।

तो हम एक भिन्नात्मक गुणांक का उपयोग करने जा रहे हैं, कहते हैं, एस , और अब, चलो कहते हैं कि हमें एन मिलाऑडियो नमूनों के सेट जो सिंक से बाहर थे। जिन नमूनों की हम सिंक्रोनाइज़ नहीं करते हैं, उनकी संख्या भी बहुत भिन्न हो सकती है, इसलिए हम औसत मूल्य लेते हैं कि उनमें से प्रत्येक कितना सिंक्रनाइज़ नहीं है। उदाहरण के लिए, पहला कॉल दिखा सकता है कि हम 40 एमएस के लिए सिंक्रनाइज़ नहीं हैं, 50 एमएस के लिए अगला और इसी तरह। लेकिन हम एक सरल मतलब नहीं लेने जा रहे हैं, क्योंकि सबसे हाल के मूल्य उन लोगों की तुलना में अधिक महत्वपूर्ण हैं जो उनके सामने आते हैं। तो, हम एक भिन्न गुणांक का उपयोग करने जा रहे हैं, कहते हैं, ग , और अंतर को संक्षेप में इस प्रकार है: diff_sum = new_diff + diff_sum * c । जब हम औसत अंतर खोजने के लिए तैयार होते हैं, तो हम बस avg_diff = की गणना करते हैंdiff_sum * (1 - c )।

यहां क्या बकवास चल रही है? समीकरण किसी तरह के जादू की तरह दिखता है। खैर, यह मूल रूप से भार के रूप में एक ज्यामितीय श्रृंखला का उपयोग करके एक भारित औसत है। मुझे नहीं पता कि इसके लिए कोई नाम है (मैंने विकिपीडिया पर भी जाँच की है!), लेकिन अधिक जानकारी के लिए, यहाँ एक स्पष्टीकरण है (या यहाँ: weightedmean.txt )।

यहाँ हमारा कार्य कैसा दिखता है:

/* Add or subtract samples to get a better sync, return new
   audio buffer size */
int synchronize_audio(VideoState *is, short *samples,
		      int samples_size, double pts) {
  int n;
  double ref_clock;
  
  n = 2 * is->audio_st->codec->channels;
  
  if(is->av_sync_type != AV_SYNC_AUDIO_MASTER) {
    double diff, avg_diff;
    int wanted_size, min_size, max_size, nb_samples;
    
    ref_clock = get_master_clock(is);
    diff = get_audio_clock(is) - ref_clock;

    if(diff < AV_NOSYNC_THRESHOLD) {
      // accumulate the diffs
      is->audio_diff_cum = diff + is->audio_diff_avg_coef
	* is->audio_diff_cum;
      if(is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
	is->audio_diff_avg_count++;
      } else {
	avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);

       /* Shrinking/expanding buffer code.... */

      }
    } else {
      /* difference is TOO big; reset diff stuff */
      is->audio_diff_avg_count = 0;
      is->audio_diff_cum = 0;
    }
  }
  return samples_size;
}

तो हमारे साथ सब कुछ ठीक है; हम लगभग जानते हैं कि ध्वनि वीडियो के साथ या हम एक घड़ी के रूप में क्या उपयोग करते हैं, के साथ संगत नहीं है। तो, चलिए अब गणना करते हैं कि इस कोड को "बफर कोड को कम करना / बढ़ाना" करके इस कोड में कितने नमूने जोड़ने या त्यागने की आवश्यकता है:

if(fabs(avg_diff) >= is->audio_diff_threshold) {
  wanted_size = samples_size + 
  ((int)(diff * is->audio_st->codec->sample_rate) * n);
  min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX)
                             / 100);
  max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) 
                             / 100);
  if(wanted_size < min_size) {
    wanted_size = min_size;
  } else if (wanted_size > max_size) {
    wanted_size = max_size;
  }

याद रखें कि Audio_length * ( sample_rate * # of channel * 2) ऑडियो के Audio_length सेकंड में नमूनों की संख्या है । इसलिए, हम जितने नमूने चाहते हैं, वे उन नमूनों की संख्या के बराबर होंगे जो हमारे पास पहले से हैं, या उन नमूनों की संख्या शून्य है जो उस समय की मात्रा के अनुरूप हैं, जिसके दौरान ध्वनि बजाई गई थी। हम इस पर भी एक सीमा निर्धारित करेंगे कि हमारा सुधार कितना बड़ा या छोटा हो सकता है, क्योंकि यदि हम अपने बफर को बहुत अधिक बदलते हैं, तो यह उपयोगकर्ता के लिए बहुत कष्टप्रद होगा।

नमूनों की संख्या का सुधार

अब हमें ध्वनि को ठीक करने की आवश्यकता है। आपने देखा होगा कि हमारा सिंक्रोनाइज़_ऑडियो फ़ंक्शन एक नमूना आकार देता है, जो तब हमें यह बताता है कि स्ट्रीम को भेजने के लिए कितने बाइट्स हैं। इसलिए हमें बस नमूना आकार को वांछित मूल्य में समायोजित करने की आवश्यकता है। यह नमूना आकार को कम करने के लिए काम करता है। लेकिन अगर आपको इसे बढ़ाने की आवश्यकता है, तो हम केवल नमूना आकार नहीं बढ़ा सकते, क्योंकि बफर में अधिक डेटा नहीं है! इसलिए, हमें थोड़ा जोड़ना चाहिए। लेकिन वास्तव में क्या जोड़ना है? ऑडियो को एक्सट्रपलेशन करने की कोशिश करना मूर्खतापूर्ण होगा, इसलिए चलिए पिछले नमूने के मूल्य को बफर में जोड़ते हुए ऑडियो का उपयोग करें।

if(wanted_size < samples_size) {
  /* remove samples */
  samples_size = wanted_size;
} else if(wanted_size > samples_size) {
  uint8_t *samples_end, *q;
  int nb;

  /* add samples by copying final samples */
  nb = (samples_size - wanted_size);
  samples_end = (uint8_t *)samples + samples_size - n;
  q = samples_end + n;
  while(nb > 0) {
    memcpy(q, samples_end, n);
    q += n;
    nb -= n;
  }
  samples_size = wanted_size;
}

अब हम नमूना आकार वापस कर रहे हैं, और हम इस फ़ंक्शन के साथ कर रहे हैं। अब हमें बस यही करना है:

void audio_callback(void *userdata, Uint8 *stream, int len) {

  VideoState *is = (VideoState *)userdata;
  int len1, audio_size;
  double pts;

  while(len > 0) {
    if(is->audio_buf_index >= is->audio_buf_size) {
      /* We have already sent all our data; get more */
      audio_size = audio_decode_frame(is, is->audio_buf, sizeof(is->audio_buf), &pts);
      if(audio_size < 0) {
	/* If error, output silence */
	is->audio_buf_size = 1024;
	memset(is->audio_buf, 0, is->audio_buf_size);
      } else {
	audio_size = synchronize_audio(is, (int16_t *)is->audio_buf,
				       audio_size, pts);
	is->audio_buf_size = audio_size;

हमने जो कुछ किया था, वह सिंक्रोनाइज़_ऑडियो कॉल सम्मिलित कर रहा था । (इसके अलावा, स्रोत कोड की जांच करना सुनिश्चित करें, जिसमें हम उन चरों को आरंभीकृत करते हैं, जिन्हें मैं परिभाषित करने की जहमत नहीं उठाता।)

और अंतिम, इससे पहले कि हम समाप्त करें: हमें यह सुनिश्चित करने के लिए "यदि" शर्त को जोड़ने की आवश्यकता है कि हम वीडियो को सिंक्रनाइज़ नहीं करते हैं: यह मुख्य घड़ी है:

if(is->av_sync_type != AV_SYNC_VIDEO_MASTER) {
  ref_clock = get_master_clock(is);
  diff = vp->pts - ref_clock;

  /* Skip or repeat the frame. Take delay into account
     FFPlay still doesn't "know if this is the best guess." */
  sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay :
                    AV_SYNC_THRESHOLD;
  if(fabs(diff) < AV_NOSYNC_THRESHOLD) {
    if(diff <= -sync_threshold) {
      delay = 0;
    } else if(diff >= sync_threshold) {
      delay = 2 * delay;
    }
  }
}

और यह काम करता है! सुनिश्चित करें कि आप किसी भी वैरिएबल को इनिशियलाइज़ करने के लिए सोर्स फाइल की जाँच करें जिसे मैंने डिफाइन या इनिशियलाइज़ करने की जहमत नहीं उठाई। फिर संकलन करें:

gcc -o tutorial06 tutorial06.c -lavutil -lavformat -lavcodec -lswscale -lz -lm \
`sdl-config --cflags --libs`

और उड़ान सामान्य होगी।

अंतिम पाठ में हम उल्टा करेंगे।

पाठ 7: खोज ← । →

पूरी लिस्टिंग tutorial07.c

// tutorial05.c
// A pedagogical video player that really works!
//
// Code based on FFplay, Copyright (c) 2003 Fabrice Bellard, 
// and a tutorial by Martin Bohme (boehme@inb.uni-luebeckREMOVETHIS.de)
// Tested on Gentoo, CVS version 5/01/07 compiled with GCC 4.1.1
// With updates from https://github.com/chelyaev/ffmpeg-tutorial
// Updates tested on:
// LAVC 54.59.100, LAVF 54.29.104, LSWS 2.1.101, SDL 1.2.15
// on GCC 4.7.2 in Debian February 2015
// Use
//
// gcc -o tutorial05 tutorial05.c -lavformat -lavcodec -lswscale -lz -lm `sdl-config --cflags --libs`
// to build (assuming libavformat and libavcodec are correctly installed, 
// and assuming you have sdl-config. Please refer to SDL docs for your installation.)
//
// Run using
// tutorial04 myvideofile.mpg
//
// to play the video stream on your screen.

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#include <SDL.h>
#include <SDL_thread.h>

#ifdef __MINGW32__
#undef main /* Prevents SDL from overriding main() */
#endif

#include <stdio.h>
#include <assert.h>
#include <math.h>

// compatibility with newer API
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
#define av_frame_alloc avcodec_alloc_frame
#define av_frame_free avcodec_free_frame
#endif

#define SDL_AUDIO_BUFFER_SIZE 1024
#define MAX_AUDIO_FRAME_SIZE 192000

#define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
#define MAX_VIDEOQ_SIZE (5 * 256 * 1024)

#define AV_SYNC_THRESHOLD 0.01
#define AV_NOSYNC_THRESHOLD 10.0

#define SAMPLE_CORRECTION_PERCENT_MAX 10
#define AUDIO_DIFF_AVG_NB 20

#define FF_REFRESH_EVENT (SDL_USEREVENT)
#define FF_QUIT_EVENT (SDL_USEREVENT + 1)

#define VIDEO_PICTURE_QUEUE_SIZE 1

#define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER

typedef struct PacketQueue {
  AVPacketList *first_pkt, *last_pkt;
  int nb_packets;
  int size;
  SDL_mutex *mutex;
  SDL_cond *cond;
} PacketQueue;


typedef struct VideoPicture {
  SDL_Overlay *bmp;
  int width, height; /* source height & width */
  int allocated;
  double pts;
} VideoPicture;

typedef struct VideoState {

  AVFormatContext *pFormatCtx;
  int             videoStream, audioStream;

  int             av_sync_type;
  double          external_clock; /* external clock base */
  int64_t         external_clock_time;
  int             seek_req;
  int             seek_flags;
  int64_t         seek_pos;

  double          audio_clock;
  AVStream        *audio_st;
  AVCodecContext  *audio_ctx;
  PacketQueue     audioq;
  uint8_t         audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];
  unsigned int    audio_buf_size;
  unsigned int    audio_buf_index;
  AVFrame         audio_frame;
  AVPacket        audio_pkt;
  uint8_t         *audio_pkt_data;
  int             audio_pkt_size;
  int             audio_hw_buf_size;
  double          audio_diff_cum; /* used for AV difference average computation */
  double          audio_diff_avg_coef;
  double          audio_diff_threshold;
  int             audio_diff_avg_count;
  double          frame_timer;
  double          frame_last_pts;
  double          frame_last_delay;
  double          video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame
  double          video_current_pts; ///<current displayed pts (different from video_clock if frame fifos are used)
  int64_t         video_current_pts_time;  ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
  AVStream        *video_st;
  AVCodecContext  *video_ctx;
  PacketQueue     videoq;
  struct SwsContext *sws_ctx;

  VideoPicture    pictq[VIDEO_PICTURE_QUEUE_SIZE];
  int             pictq_size, pictq_rindex, pictq_windex;
  SDL_mutex       *pictq_mutex;
  SDL_cond        *pictq_cond;
  
  SDL_Thread      *parse_tid;
  SDL_Thread      *video_tid;

  char            filename[1024];
  int             quit;
} VideoState;

enum {
  AV_SYNC_AUDIO_MASTER,
  AV_SYNC_VIDEO_MASTER,
  AV_SYNC_EXTERNAL_MASTER,
};

SDL_Surface     *screen;
SDL_mutex       *screen_mutex;

/* Since we only have one decoding thread, the Big Struct
   can be global in case we need it. */
VideoState *global_video_state;
AVPacket flush_pkt;

void packet_queue_init(PacketQueue *q) {
  memset(q, 0, sizeof(PacketQueue));
  q->mutex = SDL_CreateMutex();
  q->cond = SDL_CreateCond();
}

int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

  AVPacketList *pkt1;
  if(pkt != &flush_pkt && av_dup_packet(pkt) < 0) {
    return -1;
  }
  pkt1 = av_malloc(sizeof(AVPacketList));
  if (!pkt1)
    return -1;
  pkt1->pkt = *pkt;
  pkt1->next = NULL;
  
  SDL_LockMutex(q->mutex);

  if (!q->last_pkt)
    q->first_pkt = pkt1;
  else
    q->last_pkt->next = pkt1;
  q->last_pkt = pkt1;
  q->nb_packets++;
  q->size += pkt1->pkt.size;
  SDL_CondSignal(q->cond);
  
  SDL_UnlockMutex(q->mutex);
  return 0;
}
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
{
  AVPacketList *pkt1;
  int ret;

  SDL_LockMutex(q->mutex);
  
  for(;;) {
    
    if(global_video_state->quit) {
      ret = -1;
      break;
    }

    pkt1 = q->first_pkt;
    if (pkt1) {
      q->first_pkt = pkt1->next;
      if (!q->first_pkt)
	q->last_pkt = NULL;
      q->nb_packets--;
      q->size -= pkt1->pkt.size;
      *pkt = pkt1->pkt;
      av_free(pkt1);
      ret = 1;
      break;
    } else if (!block) {
      ret = 0;
      break;
    } else {
      SDL_CondWait(q->cond, q->mutex);
    }
  }
  SDL_UnlockMutex(q->mutex);
  return ret;
}

static void packet_queue_flush(PacketQueue *q) {
  AVPacketList *pkt, *pkt1;

  SDL_LockMutex(q->mutex);
  for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
    pkt1 = pkt->next;
    av_free_packet(&pkt->pkt);
    av_freep(&pkt);
  }
  q->last_pkt = NULL;
  q->first_pkt = NULL;
  q->nb_packets = 0;
  q->size = 0;
  SDL_UnlockMutex(q->mutex);
}

double get_audio_clock(VideoState *is) {
  double pts;
  int hw_buf_size, bytes_per_sec, n;
  
  pts = is->audio_clock; /* maintained in the audio thread */
  hw_buf_size = is->audio_buf_size - is->audio_buf_index;
  bytes_per_sec = 0;
  n = is->audio_ctx->channels * 2;
  if(is->audio_st) {
    bytes_per_sec = is->audio_ctx->sample_rate * n;
  }
  if(bytes_per_sec) {
    pts -= (double)hw_buf_size / bytes_per_sec;
  }
  return pts;
}
double get_video_clock(VideoState *is) {
  double delta;

  delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
  return is->video_current_pts + delta;
}
double get_external_clock(VideoState *is) {
  return av_gettime() / 1000000.0;
}

double get_master_clock(VideoState *is) {
  if(is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
    return get_video_clock(is);
  } else if(is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
    return get_audio_clock(is);
  } else {
    return get_external_clock(is);
  }
}


/* Add or subtract samples to get a better sync, return new
   audio buffer size */
int synchronize_audio(VideoState *is, short *samples,
		      int samples_size, double pts) {
  int n;
  double ref_clock;

  n = 2 * is->audio_ctx->channels;
  
  if(is->av_sync_type != AV_SYNC_AUDIO_MASTER) {
    double diff, avg_diff;
    int wanted_size, min_size, max_size /*, nb_samples */;
    
    ref_clock = get_master_clock(is);
    diff = get_audio_clock(is) - ref_clock;

    if(diff < AV_NOSYNC_THRESHOLD) {
      // accumulate the diffs
      is->audio_diff_cum = diff + is->audio_diff_avg_coef
	* is->audio_diff_cum;
      if(is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
	is->audio_diff_avg_count++;
      } else {
	avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
	if(fabs(avg_diff) >= is->audio_diff_threshold) {
	  wanted_size = samples_size + ((int)(diff * is->audio_ctx->sample_rate) * n);
	  min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100);
	  max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100);
	  if(wanted_size < min_size) {
	    wanted_size = min_size;
	  } else if (wanted_size > max_size) {
	    wanted_size = max_size;
	  }
	  if(wanted_size < samples_size) {
	    /* remove samples */
	    samples_size = wanted_size;
	  } else if(wanted_size > samples_size) {
	    uint8_t *samples_end, *q;
	    int nb;

	    /* add samples by copying final sample*/
	    nb = (samples_size - wanted_size);
	    samples_end = (uint8_t *)samples + samples_size - n;
	    q = samples_end + n;
	    while(nb > 0) {
	      memcpy(q, samples_end, n);
	      q += n;
	      nb -= n;
	    }
	    samples_size = wanted_size;
	  }
	}
      }
    } else {
      /* difference is TOO big; reset diff stuff */
      is->audio_diff_avg_count = 0;
      is->audio_diff_cum = 0;
    }
  }
  return samples_size;
}

int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr) {

  int len1, data_size = 0;
  AVPacket *pkt = &is->audio_pkt;
  double pts;
  int n;

  for(;;) {
    while(is->audio_pkt_size > 0) {
      int got_frame = 0;
      len1 = avcodec_decode_audio4(is->audio_ctx, &is->audio_frame, &got_frame, pkt);
      if(len1 < 0) {
	/* if error, skip frame */
	is->audio_pkt_size = 0;
	break;
      }
      data_size = 0;
      if(got_frame) {
	data_size = av_samples_get_buffer_size(NULL, 
					       is->audio_ctx->channels,
					       is->audio_frame.nb_samples,
					       is->audio_ctx->sample_fmt,
					       1);
	assert(data_size <= buf_size);
	memcpy(audio_buf, is->audio_frame.data[0], data_size);
      }
      is->audio_pkt_data += len1;
      is->audio_pkt_size -= len1;
      if(data_size <= 0) {
	/* No data yet, get more frames */
	continue;
      }
      pts = is->audio_clock;
      *pts_ptr = pts;
      n = 2 * is->audio_ctx->channels;
      is->audio_clock += (double)data_size /
	(double)(n * is->audio_ctx->sample_rate);
      /* We have data, return it and come back for more later */
      return data_size;
    }
    if(pkt->data)
      av_free_packet(pkt);

    if(is->quit) {
      return -1;
    }
    /* next packet */
    if(packet_queue_get(&is->audioq, pkt, 1) < 0) {
      return -1;
    }
    if(pkt->data == flush_pkt.data) {
      avcodec_flush_buffers(is->audio_ctx);
      continue;
    }
    is->audio_pkt_data = pkt->data;
    is->audio_pkt_size = pkt->size;
    /* if update, update the audio clock w/pts */
    if(pkt->pts != AV_NOPTS_VALUE) {
      is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
    }
  }
}

void audio_callback(void *userdata, Uint8 *stream, int len) {

  VideoState *is = (VideoState *)userdata;
  int len1, audio_size;
  double pts;

  while(len > 0) {
    if(is->audio_buf_index >= is->audio_buf_size) {
      /* We have already sent all our data; get more */
      audio_size = audio_decode_frame(is, is->audio_buf, sizeof(is->audio_buf), &pts);
      if(audio_size < 0) {
	/* If error, output silence */
	is->audio_buf_size = 1024;
	memset(is->audio_buf, 0, is->audio_buf_size);
      } else {
	audio_size = synchronize_audio(is, (int16_t *)is->audio_buf,
				       audio_size, pts);
	is->audio_buf_size = audio_size;
      }
      is->audio_buf_index = 0;
    }
    len1 = is->audio_buf_size - is->audio_buf_index;
    if(len1 > len)
      len1 = len;
    memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
    len -= len1;
    stream += len1;
    is->audio_buf_index += len1;
  }
}

static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {
  SDL_Event event;
  event.type = FF_REFRESH_EVENT;
  event.user.data1 = opaque;
  SDL_PushEvent(&event);
  return 0; /* 0 means stop timer */
}

/* schedule a video refresh in 'delay' ms */
static void schedule_refresh(VideoState *is, int delay) {
  SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
}

void video_display(VideoState *is) {

  SDL_Rect rect;
  VideoPicture *vp;
  float aspect_ratio;
  int w, h, x, y;
  int i;

  vp = &is->pictq[is->pictq_rindex];
  if(vp->bmp) {
    if(is->video_ctx->sample_aspect_ratio.num == 0) {
      aspect_ratio = 0;
    } else {
      aspect_ratio = av_q2d(is->video_ctx->sample_aspect_ratio) *
	is->video_ctx->width / is->video_ctx->height;
    }
    if(aspect_ratio <= 0.0) {
      aspect_ratio = (float)is->video_ctx->width /
	(float)is->video_ctx->height;
    }
    h = screen->h;
    w = ((int)rint(h * aspect_ratio)) & -3;
    if(w > screen->w) {
      w = screen->w;
      h = ((int)rint(w / aspect_ratio)) & -3;
    }
    x = (screen->w - w) / 2;
    y = (screen->h - h) / 2;
    
    rect.x = x;
    rect.y = y;
    rect.w = w;
    rect.h = h;
    SDL_LockMutex(screen_mutex);
    SDL_DisplayYUVOverlay(vp->bmp, &rect);
    SDL_UnlockMutex(screen_mutex);
  }
}

void video_refresh_timer(void *userdata) {

  VideoState *is = (VideoState *)userdata;
  VideoPicture *vp;
  double actual_delay, delay, sync_threshold, ref_clock, diff;
  
  if(is->video_st) {
    if(is->pictq_size == 0) {
      schedule_refresh(is, 1);
    } else {
      vp = &is->pictq[is->pictq_rindex];
      
      is->video_current_pts = vp->pts;
      is->video_current_pts_time = av_gettime();
      delay = vp->pts - is->frame_last_pts; /* the pts from last time */
      if(delay <= 0 || delay >= 1.0) {
	/* if incorrect delay, use previous one */
	delay = is->frame_last_delay;
      }
      /* save for next time */
      is->frame_last_delay = delay;
      is->frame_last_pts = vp->pts;



      /* update delay to sync to audio if not master source */
      if(is->av_sync_type != AV_SYNC_VIDEO_MASTER) {
	ref_clock = get_master_clock(is);
	diff = vp->pts - ref_clock;
	
	/* Skip or repeat the frame. Take delay into account
	   FFPlay still doesn't "know if this is the best guess." */
	sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;
	if(fabs(diff) < AV_NOSYNC_THRESHOLD) {
	  if(diff <= -sync_threshold) {
	    delay = 0;
	  } else if(diff >= sync_threshold) {
	    delay = 2 * delay;
	  }
	}
      }
      is->frame_timer += delay;
      /* computer the REAL delay */
      actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
      if(actual_delay < 0.010) {
	/* Really it should skip the picture instead */
	actual_delay = 0.010;
      }
      schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));
      
      /* show the picture! */
      video_display(is);
      
      /* update queue for next picture! */
      if(++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {
	is->pictq_rindex = 0;
      }
      SDL_LockMutex(is->pictq_mutex);
      is->pictq_size--;
      SDL_CondSignal(is->pictq_cond);
      SDL_UnlockMutex(is->pictq_mutex);
    }
  } else {
    schedule_refresh(is, 100);
  }
}
      
void alloc_picture(void *userdata) {

  VideoState *is = (VideoState *)userdata;
  VideoPicture *vp;

  vp = &is->pictq[is->pictq_windex];
  if(vp->bmp) {
    // we already have one make another, bigger/smaller
    SDL_FreeYUVOverlay(vp->bmp);
  }
  // Allocate a place to put our YUV image on that screen
  SDL_LockMutex(screen_mutex);
  vp->bmp = SDL_CreateYUVOverlay(is->video_ctx->width,
				 is->video_ctx->height,
				 SDL_YV12_OVERLAY,
				 screen);
  SDL_UnlockMutex(screen_mutex);

  vp->width = is->video_ctx->width;
  vp->height = is->video_ctx->height;
  vp->allocated = 1;

}

int queue_picture(VideoState *is, AVFrame *pFrame, double pts) {

  VideoPicture *vp;
  int dst_pix_fmt;
  AVPicture pict;

  /* wait until we have space for a new pic */
  SDL_LockMutex(is->pictq_mutex);
  while(is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
	!is->quit) {
    SDL_CondWait(is->pictq_cond, is->pictq_mutex);
  }
  SDL_UnlockMutex(is->pictq_mutex);

  if(is->quit)
    return -1;

  // windex is set to 0 initially
  vp = &is->pictq[is->pictq_windex];

  /* allocate or resize the buffer! */
  if(!vp->bmp ||
     vp->width != is->video_ctx->width ||
     vp->height != is->video_ctx->height) {
    SDL_Event event;

    vp->allocated = 0;
    alloc_picture(is);
    if(is->quit) {
      return -1;
    }
  }
  /* We have a place to put our picture on the queue */

  if(vp->bmp) {

    SDL_LockYUVOverlay(vp->bmp);
    vp->pts = pts;
    
    dst_pix_fmt = PIX_FMT_YUV420P;
    /* point pict at the queue */

    pict.data[0] = vp->bmp->pixels[0];
    pict.data[1] = vp->bmp->pixels[2];
    pict.data[2] = vp->bmp->pixels[1];
    
    pict.linesize[0] = vp->bmp->pitches[0];
    pict.linesize[1] = vp->bmp->pitches[2];
    pict.linesize[2] = vp->bmp->pitches[1];
    
    // Convert the image into YUV format that SDL uses
    sws_scale(is->sws_ctx, (uint8_t const * const *)pFrame->data,
	      pFrame->linesize, 0, is->video_ctx->height,
	      pict.data, pict.linesize);
    
    SDL_UnlockYUVOverlay(vp->bmp);
    /* now we inform our display thread that we have a pic ready */
    if(++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {
      is->pictq_windex = 0;
    }
    SDL_LockMutex(is->pictq_mutex);
    is->pictq_size++;
    SDL_UnlockMutex(is->pictq_mutex);
  }
  return 0;
}

double synchronize_video(VideoState *is, AVFrame *src_frame, double pts) {

  double frame_delay;

  if(pts != 0) {
    /* if we have pts, set video clock to it */
    is->video_clock = pts;
  } else {
    /* if we aren't given a pts, set it to the clock */
    pts = is->video_clock;
  }
  /* update the video clock */
  frame_delay = av_q2d(is->video_ctx->time_base);
  /* if we are repeating a frame, adjust clock accordingly */
  frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
  is->video_clock += frame_delay;
  return pts;
}

int video_thread(void *arg) {
  VideoState *is = (VideoState *)arg;
  AVPacket pkt1, *packet = &pkt1;
  int frameFinished;
  AVFrame *pFrame;
  double pts;

  pFrame = av_frame_alloc();

  for(;;) {
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    pts = 0;

    // Decode video frame
    avcodec_decode_video2(is->video_ctx, pFrame, &frameFinished, packet);

    if((pts = av_frame_get_best_effort_timestamp(pFrame)) == AV_NOPTS_VALUE) {
      pts = av_frame_get_best_effort_timestamp(pFrame);
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_st->time_base);

    // Did we get a video frame?
    if(frameFinished) {
      pts = synchronize_video(is, pFrame, pts);
      if(queue_picture(is, pFrame, pts) < 0) {
	break;
      }
    }
    av_free_packet(packet);
  }
  av_frame_free(&pFrame);
  return 0;
}

int stream_component_open(VideoState *is, int stream_index) {

  AVFormatContext *pFormatCtx = is->pFormatCtx;
  AVCodecContext *codecCtx = NULL;
  AVCodec *codec = NULL;
  SDL_AudioSpec wanted_spec, spec;

  if(stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
    return -1;
  }

  codec = avcodec_find_decoder(pFormatCtx->streams[stream_index]->codec->codec_id);
  if(!codec) {
    fprintf(stderr, "Unsupported codec!\n");
    return -1;
  }

  codecCtx = avcodec_alloc_context3(codec);
  if(avcodec_copy_context(codecCtx, pFormatCtx->streams[stream_index]->codec) != 0) {
    fprintf(stderr, "Couldn't copy codec context");
    return -1; // Error copying codec context
  }


  if(codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
    // Set audio settings from codec info
    wanted_spec.freq = codecCtx->sample_rate;
    wanted_spec.format = AUDIO_S16SYS;
    wanted_spec.channels = codecCtx->channels;
    wanted_spec.silence = 0;
    wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
    wanted_spec.callback = audio_callback;
    wanted_spec.userdata = is;
    
    if(SDL_OpenAudio(&wanted_spec, &spec) < 0) {
      fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
      return -1;
    }
    is->audio_hw_buf_size = spec.size;
  }
  if(avcodec_open2(codecCtx, codec, NULL) < 0) {
    fprintf(stderr, "Unsupported codec!\n");
    return -1;
  }

  switch(codecCtx->codec_type) {
  case AVMEDIA_TYPE_AUDIO:
    is->audioStream = stream_index;
    is->audio_st = pFormatCtx->streams[stream_index];
    is->audio_ctx = codecCtx;
    is->audio_buf_size = 0;
    is->audio_buf_index = 0;
    memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
    packet_queue_init(&is->audioq);
    SDL_PauseAudio(0);
    break;
  case AVMEDIA_TYPE_VIDEO:
    is->videoStream = stream_index;
    is->video_st = pFormatCtx->streams[stream_index];
    is->video_ctx = codecCtx;

    is->frame_timer = (double)av_gettime() / 1000000.0;
    is->frame_last_delay = 40e-3;
    is->video_current_pts_time = av_gettime();

    packet_queue_init(&is->videoq);
    is->video_tid = SDL_CreateThread(video_thread, is);
    is->sws_ctx = sws_getContext(is->video_ctx->width, is->video_ctx->height,
				 is->video_ctx->pix_fmt, is->video_ctx->width,
				 is->video_ctx->height, PIX_FMT_YUV420P,
				 SWS_BILINEAR, NULL, NULL, NULL
				 );
    break;
  default:
    break;
  }
}

int decode_thread(void *arg) {

  VideoState *is = (VideoState *)arg;
  AVFormatContext *pFormatCtx;
  AVPacket pkt1, *packet = &pkt1;

  int video_index = -1;
  int audio_index = -1;
  int i;

  is->videoStream=-1;
  is->audioStream=-1;

  global_video_state = is;

  // Open video file
  if(avformat_open_input(&pFormatCtx, is->filename, NULL, NULL)!=0)
    return -1; // Couldn't open file

  is->pFormatCtx = pFormatCtx;
  
  // Retrieve stream information
  if(avformat_find_stream_info(pFormatCtx, NULL)<0)
    return -1; // Couldn't find stream information
  
  // Dump information about file onto standard error
  av_dump_format(pFormatCtx, 0, is->filename, 0);
  
  // Find the first video stream

  for(i=0; i<pFormatCtx->nb_streams; i++) {
    if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO &&
       video_index < 0) {
      video_index=i;
    }
    if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO &&
       audio_index < 0) {
      audio_index=i;
    }
  }
  if(audio_index >= 0) {
    stream_component_open(is, audio_index);
  }
  if(video_index >= 0) {
    stream_component_open(is, video_index);
  }   

  if(is->videoStream < 0 || is->audioStream < 0) {
    fprintf(stderr, "%s: could not open codecs\n", is->filename);
    goto fail;
  }

  // main decode loop

  for(;;) {
    if(is->quit) {
      break;
    }
    // seek stuff goes here
    if(is->seek_req) {
      int stream_index= -1;
      int64_t seek_target = is->seek_pos;

      if     (is->videoStream >= 0) stream_index = is->videoStream;
      else if(is->audioStream >= 0) stream_index = is->audioStream;

      if(stream_index>=0){
	seek_target= av_rescale_q(seek_target, AV_TIME_BASE_Q,
				  pFormatCtx->streams[stream_index]->time_base);
      }
      if(av_seek_frame(is->pFormatCtx, stream_index, 
		       seek_target, is->seek_flags) < 0) {
	fprintf(stderr, "%s: error while seeking\n",
		is->pFormatCtx->filename);
      } else {

	if(is->audioStream >= 0) {
	  packet_queue_flush(&is->audioq);
	  packet_queue_put(&is->audioq, &flush_pkt);
	}
	if(is->videoStream >= 0) {
	  packet_queue_flush(&is->videoq);
	  packet_queue_put(&is->videoq, &flush_pkt);
	}
      }
      is->seek_req = 0;
    }

    if(is->audioq.size > MAX_AUDIOQ_SIZE ||
       is->videoq.size > MAX_VIDEOQ_SIZE) {
      SDL_Delay(10);
      continue;
    }
    if(av_read_frame(is->pFormatCtx, packet) < 0) {
      if(is->pFormatCtx->pb->error == 0) {
	SDL_Delay(100); /* no error; wait for user input */
	continue;
      } else {
	break;
      }
    }
    // Is this a packet from the video stream?
    if(packet->stream_index == is->videoStream) {
      packet_queue_put(&is->videoq, packet);
    } else if(packet->stream_index == is->audioStream) {
      packet_queue_put(&is->audioq, packet);
    } else {
      av_free_packet(packet);
    }
  }
  /* all done - wait for it */
  while(!is->quit) {
    SDL_Delay(100);
  }

 fail:
  if(1){
    SDL_Event event;
    event.type = FF_QUIT_EVENT;
    event.user.data1 = is;
    SDL_PushEvent(&event);
  }
  return 0;
}

void stream_seek(VideoState *is, int64_t pos, int rel) {

  if(!is->seek_req) {
    is->seek_pos = pos;
    is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
    is->seek_req = 1;
  }
}

int main(int argc, char *argv[]) {

  SDL_Event       event;

  VideoState      *is;

  is = av_mallocz(sizeof(VideoState));

  if(argc < 2) {
    fprintf(stderr, "Usage: test <file>\n");
    exit(1);
  }
  // Register all formats and codecs
  av_register_all();
  
  if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
    fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
    exit(1);
  }

  // Make a screen to put our video
#ifndef __DARWIN__
        screen = SDL_SetVideoMode(640, 480, 0, 0);
#else
        screen = SDL_SetVideoMode(640, 480, 24, 0);
#endif
  if(!screen) {
    fprintf(stderr, "SDL: could not set video mode - exiting\n");
    exit(1);
  }

  screen_mutex = SDL_CreateMutex();

  av_strlcpy(is->filename, argv[1], sizeof(is->filename));

  is->pictq_mutex = SDL_CreateMutex();
  is->pictq_cond = SDL_CreateCond();

  schedule_refresh(is, 40);

  is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
  is->parse_tid = SDL_CreateThread(decode_thread, is);
  if(!is->parse_tid) {
    av_free(is);
    return -1;
  }

  av_init_packet(&flush_pkt);
  flush_pkt.data = "FLUSH";

  for(;;) {
    double incr, pos;
    SDL_WaitEvent(&event);
    switch(event.type) {
    case SDL_KEYDOWN:
      switch(event.key.keysym.sym) {
      case SDLK_LEFT:
	incr = -10.0;
	goto do_seek;
      case SDLK_RIGHT:
	incr = 10.0;
	goto do_seek;
      case SDLK_UP:
	incr = 60.0;
	goto do_seek;
      case SDLK_DOWN:
	incr = -60.0;
	goto do_seek;
      do_seek:
	if(global_video_state) {
	  pos = get_master_clock(global_video_state);
	  pos += incr;
	  stream_seek(global_video_state, (int64_t)(pos * AV_TIME_BASE), incr);
	}
	break;
      default:
	break;
      }
      break;
    case FF_QUIT_EVENT:
    case SDL_QUIT:
      is->quit = 1;
      /*
       * If the video has finished playing, then both the picture and
       * audio queues are waiting for more data.  Make them stop
       * waiting and terminate normally.
       */
      SDL_CondSignal(is->audioq.cond);
      SDL_CondSignal(is->videoq.cond);
      SDL_Quit();
      return 0;
      break;
    case FF_REFRESH_EVENT:
      video_refresh_timer(event.user.data1);
      break;
    default:
      break;
    }
  }
  return 0;

}

कमांड प्रोसेसिंग खोजें

अब हम अपने खिलाड़ी में कुछ खोज क्षमताओं को जोड़ने जा रहे हैं, क्योंकि यह वास्तव में कष्टप्रद है जब आप फिल्म को रिवाइंड नहीं कर सकते। इसके अलावा, हम देखेंगे कि av_seek_frame फ़ंक्शन का उपयोग करना कितना आसान है ।

हम कीबोर्ड पर तीर बनाने जा रहे हैं "बाएं" और "दाएं" फिल्म को आगे और पीछे थोड़ा स्क्रॉल करें, और तीर "ऊपर" और "नीचे" पहले से ही अधिक महत्वपूर्ण हैं। "थोड़ा" - यह 10 सेकंड होगा, और "बहुत कुछ" - सभी 60. इसलिए, हमें अपने मुख्य लूप को कॉन्फ़िगर करने की आवश्यकता है ताकि यह कीस्ट्रोक घटनाओं को स्वीकार करे। लेकिन तथ्य यह है कि जब हम एक कीस्ट्रोक प्राप्त करते हैं, तो हम सीधे av_seek_frame नहीं कह सकते । यह हमारे मुख्य डिकोडिंग लूप, डिकोड_थ्रेड लूप में किया जाना चाहिए। इसलिए, इसके बजाय, हम मुख्य संरचना में कुछ मान जोड़ेंगे, जिसमें खोज के लिए एक नया स्थान और कुछ खोज ध्वज होंगे:

  int             seek_req;
  int             seek_flags;
  int64_t         seek_pos;

अब हमें अपने मुख्य लूप को कॉन्फ़िगर करने की आवश्यकता है जो किस्ट्रोक्स को पकड़ता है:

  for(;;) {
    double incr, pos;

    SDL_WaitEvent(&event);
    switch(event.type) {
    case SDL_KEYDOWN:
      switch(event.key.keysym.sym) {
      case SDLK_LEFT:
	incr = -10.0;
	goto do_seek;
      case SDLK_RIGHT:
	incr = 10.0;
	goto do_seek;
      case SDLK_UP:
	incr = 60.0;
	goto do_seek;
      case SDLK_DOWN:
	incr = -60.0;
	goto do_seek;
      do_seek:
	if(global_video_state) {
	  pos = get_master_clock(global_video_state);
	  pos += incr;
	  stream_seek(global_video_state, 
                      (int64_t)(pos * AV_TIME_BASE), incr);
	}
	break;
      default:
	break;
      }
      break;

कीस्ट्रोक को पकड़ने के लिए, पहले हम देखते हैं कि क्या SDL_KEYDOWN ईवेंट हुआ । तब हम check.key.keysym.sym का उपयोग करके कौन सी कुंजी प्राप्त करते हैं । जैसे ही हमें पता चलता है कि हम किस दिशा में देख रहे हैं, हम एक नए समय की गणना करते हैं, हमारे नए get_master_clock फ़ंक्शन से मूल्य में वृद्धि को जोड़ते हैं । तब हम seek_pos मानों को सेट करने के लिए stream_seek फ़ंक्शन को कॉल करते हैं , आदि। हमारे नए समय को आंतरिक टाइमस्टैम्प इकाइयों में परिवर्तित करें । याद रखें कि स्ट्रीम में टाइमस्टैम्प को फ्रेम में मापा जाता है, सेकंड में नहीं, निम्न सूत्र का उपयोग करके: सेकंड = फ्रेम * time_base ( एफपीएस )।डिफ़ॉल्ट रूप से, एवोडेक को प्रति सेकंड 1,000,000 फ्रेम पर सेट किया जाता है (इसलिए 2 सेकंड की स्थिति में 2,000,000 का टाइमस्टैम्प होगा)। हमें इस मान को बदलने की आवश्यकता क्यों है - बाद में देखें।

यहां हमारा स्ट्रीम_सेक फ़ंक्शन है । ध्यान दें कि यदि हम पीछे जाते हैं तो हम ध्वज सेट करते हैं:

void stream_seek(VideoState *is, int64_t pos, int rel) {

  if(!is->seek_req) {
    is->seek_pos = pos;
    is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
    is->seek_req = 1;
  }
}

अब हम अपने डिकोड_थ्रेड पर चलते हैं , जहाँ हम वास्तव में खोज करते हैं। स्रोत फ़ाइलों में आप देख सकते हैं कि हमने "खोज जारी है" क्षेत्र को चिह्नित किया है। ठीक है, हम इसे अभी वहां लगाने जा रहे हैं।

खोज av_seek_frame फ़ंक्शन के आसपास केंद्रित है । यह फ़ंक्शन प्रारूप के संदर्भ, स्ट्रीम, टाइमस्टैम्प और ध्वज सेट को तर्क के रूप में लेता है। फ़ंक्शन आपके द्वारा दिए गए टाइमस्टैम्प के लिए दिखेगा। टाइमस्टैम्प की इकाई स्ट्रीम का time_base है जिसे आप फ़ंक्शन में पास करते हैं। हालांकि, आपको इसे स्ट्रीम में पास करने की आवश्यकता नहीं है (मान -1 पास करके इंगित किया गया है)। यदि आप ऐसा करते हैं, तो time_base avcodec आंतरिक समय इकाई में होगाया 1000000 एफपीएस। यही कारण है कि हम से हमारी स्थिति गुणा है AV_TIME_BASE जब हम सेट seek_pos ।

हालाँकि, कभी-कभी आप (शायद ही कभी) कुछ फ़ाइलों के लिए समस्याओं में भाग सकते हैं यदि आप स्ट्रीम के लिए av_seek_frame - 1 पास करते हैं, तो हम अपनी फ़ाइल में पहली स्ट्रीम का चयन करने जा रहे हैं और इसे av_seek_frame को पास करेंगे । यह मत भूलो कि नए "समन्वय प्रणाली" में होने के लिए हमें अपने टाइमस्टैम्प के पैमाने को बदलना होगा।

if(is->seek_req) {
  int stream_index= -1;
  int64_t seek_target = is->seek_pos;

  if     (is->videoStream >= 0) stream_index = is->videoStream;
  else if(is->audioStream >= 0) stream_index = is->audioStream;

  if(stream_index>=0){
    seek_target= av_rescale_q(seek_target, AV_TIME_BASE_Q,
                      pFormatCtx->streams[stream_index]->time_base);
  }
  if(av_seek_frame(is->pFormatCtx, stream_index, 
                    seek_target, is->seek_flags) < 0) {
    fprintf(stderr, "%s: error while seeking\n",
            is->pFormatCtx->filename);
  } else {
     /* handle packet queues... more later... */

av_rescale_q ( a , b , c ) एक ऐसा कार्य है जो टाइमस्टैम्प को एक आधार से दूसरे आधार पर मापता है। यह मूल रूप से एक * b / c की गणना करता है , लेकिन यह फ़ंक्शन काम में आता है क्योंकि यह गणना कभी-कभी अतिप्रवाह की ओर ले जाती है। AV_TIME_BASE_Q की एक आंशिक संस्करण है AV_TIME_BASE । वे पूरी तरह से अलग हैं: AV_TIME_BASE * time_in_seconds = avcodec_timestamp और AV_TIME_BASE_Q * avcodec_timestamp = time_in_seconds (लेकिन उस AV_TIME_BASE_Qवास्तव में एक AVRational ऑब्जेक्ट है , इसलिए आपको इसे संसाधित करने के लिए avcodec में विशेष q फ़ंक्शन का उपयोग करने की आवश्यकता है)।

बफर सफाई

इसलिए, हम अपनी खोजों को सही ढंग से सेट करते हैं, लेकिन अभी तक समाप्त नहीं हुए हैं। याद रखें, क्या हमारे पास पैकेट संचित करने के लिए एक कतार कॉन्फ़िगर है? अब जब हम एक अलग टाइमस्टैम्प में हैं, तो हमें इस कतार को साफ़ करने की आवश्यकता है, अन्यथा मूवी में खोज नहीं चलेगी! इसके अलावा, एवोडेक के पास अपने स्वयं के आंतरिक बफ़र हैं, जिन्हें प्रत्येक स्ट्रीम के लिए फ्लश करने की भी आवश्यकता है।

ऐसा करने के लिए, आपको पहले एक फ़ंक्शन लिखना होगा जो हमारे पैकेट कतार को साफ़ करता है। फिर आपको किसी तरह ऑडियो और वीडियो स्ट्रीम को निर्देश देने की आवश्यकता है कि उन्होंने एवॉडेक आंतरिक बफ़र्स को साफ़ किया है । हम इसे साफ करने के बाद एक विशेष पैकेट को कतार में रख कर ऐसा कर सकते हैं, और जब वे (धागे) इस विशेष पैकेट की खोज करते हैं, तो वे अपने बफ़र्स को साफ कर देंगे।

चलो रीसेट फ़ंक्शन के साथ शुरू करते हैं। यह वास्तव में काफी सरल है, इसलिए मैं आपको केवल कोड दिखाऊंगा:

static void packet_queue_flush(PacketQueue *q) {
  AVPacketList *pkt, *pkt1;

  SDL_LockMutex(q->mutex);
  for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
    pkt1 = pkt->next;
    av_free_packet(&pkt->pkt);
    av_freep(&pkt);
  }
  q->last_pkt = NULL;
  q->first_pkt = NULL;
  q->nb_packets = 0;
  q->size = 0;
  SDL_UnlockMutex(q->mutex);
}

अब जब कतार साफ हो गई है, तो हमारे "क्लींजिंग पैकेट" को जोड़ें। लेकिन पहले, यह परिभाषित करना अच्छा होगा कि यह क्या है और इसे बनाएं:

AVPacket flush_pkt;

main() {
  ...
  av_init_packet(&flush_pkt);
  flush_pkt.data = "FLUSH";
  ...
}

अब इस पैकेज को कतार में रखें:

  } else {
    if(is->audioStream >= 0) {
      packet_queue_flush(&is->audioq);
      packet_queue_put(&is->audioq, &flush_pkt);
    }
    if(is->videoStream >= 0) {
      packet_queue_flush(&is->videoq);
      packet_queue_put(&is->videoq, &flush_pkt);
    }
  }
  is->seek_req = 0;
}

(यह कोड स्निपेट decode_thread के लिए उपरोक्त कोड स्निपेट को जारी रखता है ।) हमें भी packet_queue_put को संशोधित करने की आवश्यकता है ताकि हम सफाई के लिए एक विशेष पैकेज की नकल न करें:

int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

  AVPacketList *pkt1;
  if(pkt != &flush_pkt && av_dup_packet(pkt) < 0) {
    return -1;
  }

और फिर ऑडियो और वीडियो स्ट्रीम में हमने इस कॉल को packet_queue_get के ठीक बाद avcodec_flush_buffers में डाल दिया :

    if(packet_queue_get(&is->audioq, pkt, 1) < 0) {
      return -1;
    }
    if(pkt->data == flush_pkt.data) {
      avcodec_flush_buffers(is->audio_st->codec);
      continue;
    }

उपरोक्त कोड स्निपेट "वीडियो" द्वारा "ऑडियो" के प्रतिस्थापन के साथ, वीडियो स्ट्रीम के लिए बिल्कुल समान है।

यह बात है! हमने कर दिया! अपने खिलाड़ी को संकलित करें:

gcc -o tutorial07 tutorial07.c -lavutil -lavformat -lavcodec -lswscale -lz -lm \
`sdl-config --cflags --libs`

और सी के 1000 से कम लाइनों में किए गए अपने मूवी प्लेयर का आनंद लें!

हालांकि, निश्चित रूप से, बहुत सी चीजें हैं जिन्हें जोड़ा या सुधार किया जा सकता है।

अंतभाषण ← ⇑ →

इसलिए, हमें एक काम करने वाला खिलाड़ी मिला है, लेकिन निश्चित रूप से यह उतना अच्छा नहीं है जितना यह हो सकता है। फ़ाइल को संशोधित करना और बहुत सी उपयोगी चीजों को जोड़ना संभव होगा:

इसका सामना करते हैं, यह खिलाड़ी बेकार है। Ffplay.c का संस्करण, जिस पर यह आधारित है, पूरी तरह से पुराना है, और परिणामस्वरूप, इस ट्यूटोरियल को पूरी तरह से संशोधित करने की आवश्यकता है। यदि आप FFmpeg पुस्तकालयों का उपयोग करके अधिक गंभीर परियोजनाओं पर आगे बढ़ना चाहते हैं, तो मैं दृढ़ता से अनुशंसा करता हूं कि आप अगले कार्य के रूप में ffplay.c के नवीनतम संस्करण की जांच करें।
हमारे कोड में त्रुटि हैंडलिंग भयानक है और इसे बेहतर तरीके से लागू किया जा सकता है।
, , , . , paused , , . , , . av_read_play. - , . , , . : , ffplay.c.
.
. , , , , VOB-.
. , .
. .
, , , , YUV, time_base.
.
--, ; ffplay.c .

यदि आप FFmpeg के बारे में अधिक जानना चाहते हैं, तो यहां हमने हर चीज से दूर माना है। अगला चरण मल्टीमीडिया कोडिंग का अध्ययन करना है। फ़ाइल output_example.c के साथ शुरू करना सबसे अच्छा है , जो आपको FFmpeg वितरण में मिलेगा। मैं इस विषय पर पहले से ही एक और पाठ्यपुस्तक लिख सकता था, लेकिन इस गाइड को पार करने की संभावना नहीं है।

युपीडी।बहुत समय पहले मैंने इस पाठ को अपडेट नहीं किया था, लेकिन इस बीच दुनिया अभी भी स्थिर नहीं है। इस ट्यूटोरियल को केवल सरल एपीआई अपडेट की आवश्यकता है; बुनियादी अवधारणाओं के संदर्भ में बहुत कम बदल गया है। इनमें से अधिकांश अपडेट ने वास्तव में कोड को सरल बनाया है। हालाँकि, हालाँकि मैंने पूरे कोड पर चलकर इसे अपडेट किया, लेकिन FFplay अभी भी इस खिलौना खिलाड़ी से बेहतर है। दिल पर हाथ रखकर, हम मानते हैं: इन पाठों में हमने एक बहुत ही घटिया फिल्म खिलाड़ी लिखा है। इसलिए, यदि आज (या भविष्य में) आप इस ट्यूटोरियल को बेहतर बनाना चाहते हैं, तो मेरा सुझाव है कि आप अपने आप को FFplay के साथ परिचित करें और पता करें कि क्या गायब है। मेरा मानना है कि यह मुख्य रूप से वीडियो उपकरण के उपयोग की चिंता करता है, लेकिन, संभवतः, मुझे कुछ अन्य स्पष्ट चीजें याद आ रही हैं। शायद मौजूदा एफएफप्ले के साथ तुलना करने से कुछ चीजों का एक फिर से लिखना होगा - मैंने इसे अभी तक नहीं देखा है।

लेकिन मुझे बहुत गर्व है कि इन वर्षों में मेरे काम ने बहुत मदद की है, यहां तक कि इस तथ्य को भी ध्यान में रखते हुए कि लोग अक्सर कहीं और कोड खोजते थे। मैं चेलियावी का बहुत आभारी हूं , जिन्होंने खुद को उन सभी कार्यों की जगह लेने की दिनचर्या दी है जो मैंने इस मोनोग्राफ 8 (!) सालों पहले लिखे थे।

मैं इस उम्मीद में खुश हूं कि ये सबक उपयोगी नहीं थे और उबाऊ नहीं थे। यदि इस गाइड के संबंध में कोई सुझाव, त्रुटियां, शिकायतें, धन्यवाद आदि हैं, तो कृपया मुझे डॉगर डॉग जीमेल डॉट कॉम पर लिखें। और हाँ, यह कोई मतलब नहीं है मुझे अपने FFmpeg परियोजना के साथ मदद करने के लिए पूछना। इसी तरह के बहुत से पत्र हैं ।

परिशिष्ट 1. कार्यों की सूची ← ⇑ →

int avformat_open_input(AVFormatContext **ptr, const char * filename, AVInputFormat *fmt, AVDictionary **options)

मीडिया फ़ाइल का नाम खोलता है, ptr में निर्दिष्ट पते में प्रारूप संदर्भ बचाता है ।

fmt : यदि NULL नहीं है, तो फ़ाइल फॉर्मेट सेट करें।
buf_size : बफर आकार (वैकल्पिक)।
विकल्प : AV ढाँचा AVFormatContext और demultiplexer के मापदंडों से आबाद है ।

void avformat_close_input(AVFormatContext **s)

मीडिया फ़ाइल बंद करता है। हालाँकि, यह कोडेक्स को बंद नहीं करता है।

nt avio_open2 (AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)

Url में निर्दिष्ट संसाधन का उपयोग करने के लिए I / O संदर्भ बनाता है ।

s : AVIOContext को उस जगह पर पॉइंटर बनाया जाएगा । विफलता के मामले में, निर्दिष्ट मान NULL पर सेट है।
url : एक्सेस करने के लिए संसाधन का नाम।
झंडे : यूआरएल में निर्दिष्ट संसाधन के उद्घाटन को नियंत्रित करते हैं ।
int_cb : प्रोटोकॉल स्तर के उपयोग के लिए कॉलबैक बाधित।
विकल्प : निजी प्रोटोकॉल मापदंडों के साथ आबाद एक शब्दकोश। जब फ़ंक्शन लौटता है, तो पैरामीटर को नष्ट कर दिया जाएगा और एक हुक युक्त विकल्पों के साथ प्रतिस्थापित किया जाएगा जो नहीं पाए गए थे। हो सकता है NULL हो।

int av_dup_packet(AVPacket *pkt)

बेशक, यह एक हैक है: यदि यह पैकेज आवंटित नहीं किया गया है, तो हम इसे यहां पोस्ट करते हैं। सफलता पर 0 या विफलता पर AVERROR_NOMEM देता है।

int av_find_stream_info(AVFormatContext *s, AVDictionary **options)

यह फ़ंक्शन गैर-स्पष्ट स्ट्रीम जानकारी के लिए खोज करता है, जैसे फ्रेम दर। यह हेडर रहित फ़ाइल स्वरूपों जैसे एमपीईजी के लिए उपयोगी है। फ़ाइल खोलने के बाद कॉल करने की अनुशंसा की जाती है। रिटर्न> = 0 यदि सफल हो, त्रुटि के मामले में AVERROR_ *।

AVFrame *avcodec_free_frame()

Av_frame_free का पुराना नाम। 55.28.1 lavc में बदला।

void av_frame_free (AVFrame **frame)

इसमें एक फ्रेम और किसी भी गतिशील रूप से आवंटित वस्तुओं को जारी करता है, उदाहरण के लिए, Extended_data।

void av_free(void *ptr)

Av_malloc () या av_realloc () का उपयोग करके आबंटित मेमोरी को रिलीज़ करता है। आप इस फ़ंक्शन को ptr == NULL के साथ कॉल कर सकते हैं। यह अनुशंसा की जाती है कि आप इसके बजाय av_freep () को कॉल करें।

void av_freep(void *ptr)

मेमोरी को फ्रीज करता है और पॉइंटर को NULL में सेट करता है। आंतरिक रूप से av_free () का उपयोग करता है।

void av_free_packet(AVPacket *pkt)

पैकेज विनाश विधि (pkt-> विनाश) के चारों ओर लपेटें।

int64_t av_gettime()

माइक्रोसेकंड में वर्तमान समय प्राप्त करें।

void av_init_packet(AVPacket *pkt)

वैकल्पिक पैकेज फ़ील्ड प्रारंभ करना।

void *av_malloc(unsigned int size)

स्मृति आवंटन बाइट आकार संरेखण के साथ सभी मेमोरी एक्सेस के लिए उपयुक्त है (वैक्टर सहित, यदि सीपीयू पर उपलब्ध है)। av_malloc (0) को एक गैर-शून्य सूचक लौटना चाहिए।

void *av_mallocz(unsigned int size)

Av_malloc () के रूप में समान है, लेकिन स्मृति को शून्य से आरंभ करता है।

double av_q2d(AVRational a)

दोहरीकरण।

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

अगली स्ट्रीम फ़्रेम लौटाता है। सूचना को pkt में एक पैकेज के रूप में संग्रहीत किया जाता है।

लौटा पैकेज अगले av_read_frame () तक या av_close_input_file () तक मान्य है और av_free_packet का उपयोग करके इसे मुक्त किया जाना चाहिए। एक वीडियो पैकेज में ठीक एक फ्रेम होता है। ऑडियो के लिए, इसमें एक पूर्णांक संख्या में फ़्रेम होते हैं यदि प्रत्येक फ़्रेम में एक ज्ञात निश्चित आकार होता है (उदाहरण के लिए, पीसीएम या एडीपीसीएम डेटा)। यदि ऑडियो फ़्रेम चर आकार (उदाहरण के लिए, एमपीईजी ऑडियो) के होते हैं, तो इसमें एक फ्रेम होता है।

pkt-> pts, pkt-> dts और pkt-> अवधि हमेशा AVStream.timebase की इकाइयों में सही मान पर सेट होती है (और यह माना जाता है कि प्रारूप उन्हें प्रदान नहीं कर सकता है)। pkt-> pts AV_NOPTS_VALUE हो सकते हैं यदि वीडियो प्रारूप में B फ़्रेम हैं, तो यदि आप पेलोड को अनपैक नहीं कर रहे हैं, तो pkt-> dts पर भरोसा करना बेहतर है।

लौटा परिणाम: 0, अगर सब कुछ ठीक है, <0, अगर कोई त्रुटि है या फ़ाइल का अंत है।

void av_register_all();

पुस्तकालय में सभी कोडक पंजीकृत करता है।

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

एक * bq / cq लौटाता है ।

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

एक टाइमस्टैम्प पर एक कुंजीफ्रेम की खोज करता है।

stream_index : अगर stream_index -1 है, तो डिफ़ॉल्ट स्ट्रीम चयनित है और टाइमस्टैम्प स्वचालित रूप से AV_TIME_BASE इकाइयों से स्ट्रीम-विशिष्ट time_base में परिवर्तित हो जाता है।
टाइमस्टैम्प : टाइमस्टैम्प को AVStream.time_base की इकाइयों में मापा जाता है, या यदि कोई स्ट्रीम निर्दिष्ट नहीं है, तो AV_TIME_BASE की इकाइयों में।
झंडे : दिशा और खोज मोड के बारे में पैरामीटर सेट करें:
AVSEEK_FLAG_ANY: किसी भी फ्रेम में खोजें, न कि केवल कुंजी।
AVSEEK_FLAG_BACKWARD: विपरीत दिशा में खोजें।
AVSEEK_FLAG_BYTE: बाइट्स में स्थिति के आधार पर खोजें।

AVFrame *avcodec_alloc_frame()

Av_frame_alloc का पुराना नाम। 55.28.1 lavc में बदला।

AVFrame *av_frame_alloc()

एक AVFrame का चयन करता है और इसे इनिशियलाइज़ करता है। Av_frame_free () का उपयोग करके मुक्त किया जा सकता है।

int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)

एक ऑडियो फ्रेम को अवाप्केट से फ्रेम तक डिकोड करता है। Avcodec_decode_audio4 () फ़ंक्शन AVPacket से एक ऑडियो फ़ाइल को डीकोड करता है। इसके डिकोडिंग के लिए, एक ऑडियो कोडेक का उपयोग किया जाता है, जो avcodec_open2 () का उपयोग करके avctx से जुड़ा था। परिणामी डिकोड किए गए फ्रेम को निर्दिष्ट AVFrame में संग्रहीत किया जाता है। यदि फ़्रेम अनपैक किया गया है, तो यह get_frame_ptr को 1 पर सेट करेगा।

चेतावनी: इनपुट बफ़र, avpkt-> डेटा, FF_INPUT_BUFFER_PADDING_SIZE वास्तविक रीड बाइट्स से बड़ा होना चाहिए, क्योंकि कुछ अनुकूलित बिटस्ट्रीम पाठक एक समय में 32 या 64 बिट्स पढ़ते हैं और पढ़ सकते हैं। समाप्त।

avctx : कोडेक संदर्भ।
फ्रेम : लक्ष्य फ्रेम।
got_frame_ptr : लक्ष्य int, जो अगर फ्रेम अनपैक किया गया था तो सेट किया जाएगा।
AVPKT: AVPacket युक्त ऑडियो।

लौटाया गया परिणाम: यदि कोई त्रुटि लौटा दी जाती है, तो एक ऋणात्मक मान वापस आ जाता है, अन्यथा, इनपुट AVPacket से उपयोग किए जाने वाले बाइट्स की संख्या वापस आ जाती है।

int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *frameFinished, const AVPacket *avpkt)

बफ़ से एक छवि के लिए एक वीडियो फ्रेम डिकोड करता है। Avcodec_decode_video2 () फ़ंक्शन buf_size के इनपुट बफ़र से एक वीडियो फ़्रेम को डीकोड करता है। इसके डिकोडिंग के लिए, एक वीडियो कोडेक का उपयोग किया जाता है, जो avcodec_open2 () का उपयोग करके avctx से जुड़ा था। परिणामस्वरूप डिकोड किया गया फ्रेम चित्र में सहेजा गया है।

चेतावनी: संरेखण उदाहरण और बफर समस्याएं जो avcodec_decode_audio4 पर लागू होती हैं और साथ ही इस फ़ंक्शन पर भी लागू होती हैं।

avctx : कोडेक संदर्भ।
चित्र : AVFrame जिसमें डिकोड किया गया वीडियो सहेजा जाएगा।
फ्रेमफिनिश : शून्य यदि कोई फ्रेम अनपैक नहीं किया जा सकता है, अन्यथा यह शून्य के बराबर नहीं है।
avpkt: इनपुट एवीपैकेट जिसमें इनपुट बफर है। आप av_init_packet () का उपयोग करके इस तरह का पैकेज बना सकते हैं, फिर, निर्दिष्ट डेटा और आकार होने पर, कुछ डिकोडरों को अतिरिक्त रूप से अन्य क्षेत्रों की आवश्यकता हो सकती है, जैसे कि झंडे और AV_PKT_FLAG_KEY। सभी डिकोडर संभव के रूप में कुछ क्षेत्रों का उपयोग करने के लिए डिज़ाइन किए गए हैं।

लौटाया गया परिणाम: गलती पर, एक नकारात्मक मान लौटा दिया जाता है, अन्यथा बाइट्स की संख्या का उपयोग किया जाता है या शून्य होता है यदि कोई फ्रेम विघटित नहीं हो सकता है।

int64_t av_frame_get_best_effort_timestamp (const AVFrame *frame)

AVFrame ऑब्जेक्ट से best_effort_timestamp प्राप्त करने के लिए एक सरल एक्सेस विधि।

AVCodec *avcodec_find_decoder(enum CodecID id)

कोडक के साथ डिकोडर की खोज करता है। त्रुटि पर पूर्ण रिटर्न देता है। यह AVFormatContext में codecCtx-> codec_id का उपयोग करके स्ट्रीम से आवश्यक AVCodecContext प्राप्त करने के बाद कहा जाना चाहिए।

void avcodec_flush_buffers(AVCodecContetx *avctx)

बफर फ्लश। किसी अन्य स्ट्रीम में खोज या स्विच करने पर कॉल किया जाता है।

AVCodecContext * avcodec_alloc_context3 (const AVCodec *codec)

AVCodecContext असाइन करता है और डिफ़ॉल्ट मानों के लिए अपने फ़ील्ड सेट करता है।

int avcodec_copy_context (AVCodecContext *dest, const AVCodecContext *src)

स्रोत AVCodecContext की सेटिंग को लक्ष्य AVCodecContext पर कॉपी करें। गंतव्य कोडेक का परिणामी संदर्भ बंद हो जाएगा, अर्थात। वीडियो / ऑडियो डेटा को डीकोड / एनकोड करने के लिए इस AVCodecContext का उपयोग करने से पहले आपको avcodec_open2 () को कॉल करना होगा।

गंतव्य :, avcodec_alloc_context3 (शून्य) के साथ प्रारंभ किया जाना चाहिए अन्यथा यह आरंभ नहीं किया जा जाएगा।

int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)

Initializes कोडेक में निर्दिष्ट उपयोग करने के लिए avctx कोडेक । Avcodec_find_decoder के बाद उपयोग किया जाना चाहिए। सफलता पर शून्य और त्रुटि पर नकारात्मक मान देता है।

int avpicture_fill(AVPicture *picture, uint8_t *ptr, int pix_fmt, int width, int height)

तस्वीर को उस बिंदु पर सेट करता है, जो ptr बफर , pix_fmt प्रारूप और निर्दिष्ट चौड़ाई और ऊंचाई के साथ इंगित करता है । बाइट्स में छवि डेटा का आकार लौटाता है।

int avpicture_get_size(int pix_fmt, int width, int height)

गणना करता है कि किसी दिए गए चौड़ाई, ऊंचाई और छवि प्रारूप की छवि के लिए कितने बाइट्स की आवश्यकता है।

struct SwsContext* sws_getContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, double *param)

Sws_scale में उपयोग के लिए SwsContext देता है।

srcW , srcH , srcFormat : चौड़ाई, ऊंचाई और वांछित पिक्सेल का प्रारूप।
dstW , dstH , dstFormat : अंतिम पिक्सल की चौड़ाई, ऊंचाई और प्रारूप।
झंडे : उपयोग करने के लिए स्केलिंग विधि।
निम्नलिखित विकल्प उपलब्ध हैं: SWS_FAST_BILINEAR, SWS_BILINEAR, SWS_BICUBIC, SWS_XINT, SWS_POINT, SWS_AREA, SWS_BICUBLIN, SWS_GAUSS, SWS_SINC, SWS_LANCZOS, SWS_SPLINE।
अन्य झंडे में CPU क्षमता झंडे शामिल हैं: SWS_CPU_CAPS_MMX, SWS_CPU_CAPS_MMX2, SWS_CPU_CAPS_3DNOW, SWS_CPU_CAPS_ALTIVEC।
अन्य झंडे में (वर्तमान में पूरी तरह से लागू नहीं) SWS_FULL_CHR_H_INT, SWS_FULL_CHR_H_INP और SWS_DIRECT_BGR शामिल हैं।
अंत में, SWS_ACCURATE_RND है और शायद शुरुआती, SWS_PRINT_INFO के लिए सबसे उपयोगी है।
मुझे नहीं पता कि उनमें से अधिकांश क्या करते हैं। शायद मुझे लिखें?
srcFilter , dstFilter : स्रोत और गंतव्य के लिए SwsFilter। SwsFilter रंग / चमक को छानने में सक्षम बनाता है। डिफॉल्ट मान शून्य है।
परम : गुणांक वाले int [2] बफर के लिए एक संकेतक होना चाहिए। प्रलेखित नहीं। यह मानक स्केलिंग एल्गोरिदम को थोड़ा संशोधित करने के लिए उपयोग किया जाता है। डिफॉल्ट मान शून्य है। केवल विशेषज्ञों के लिए!

int sws_scale(SwsContext *c, uint8_t *src, int srcStride[], int srcSliceY, int srcSliceH, uint8_t dst[], int dstStride[]
sws_scale(sws_ctx, pFrame->data, pFrame->linesize, 0, is->video_st->codec->height, pict.data, pict.linesize);

हमारे SwsContext * c में हमारी सेटिंग के अनुसार src में स्केल डेटा । srcStride और dstStride स्रोत और गंतव्य पंक्ति आकार हैं।

SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param)

एक कॉलबैक फ़ंक्शन जोड़ता है जो निर्दिष्ट संख्या में मिलीसेकंड के बाद चलता है। कॉलबैक फ़ंक्शन SDL_AddTimer कॉल से वर्तमान टाइमर अंतराल और उपयोगकर्ता द्वारा प्रदान किया गया पैरामीटर पास करता है और अगले टाइमर अंतराल को वापस करता है। (यदि कॉलबैक का रिटर्न मान पारित मूल्य से मेल खाता है, तो टाइमर उसी गति से काम करना जारी रखता है।) यदि कॉलबैक का रिटर्न मान 0 है, तो टाइमर रद्द कर दिया गया है।
वर्तमान टाइमर को रद्द करने का एक और तरीका है SDL_RemoveTimer को टाइमर पहचानकर्ता (जिसे SDL_AddTimer से लौटाया गया था) को कॉल करना।

टाइमर कॉलबैक फ़ंक्शन आपके मुख्य प्रोग्राम की तुलना में एक अलग थ्रेड पर निष्पादित हो सकता है, और इसलिए स्वयं से किसी भी फ़ंक्शन को कॉल नहीं करना चाहिए। हालाँकि, आप हमेशा SDL_PushEvent पर कॉल कर सकते हैं।

टाइमर के विस्तार की डिग्री प्लेटफॉर्म पर निर्भर करती है, लेकिन आपको यह उम्मीद करने की आवश्यकता है कि यह कम से कम 10 एमएस है, क्योंकि यह सबसे आम मूल्य है। इसका मतलब है कि यदि आप 16 एमएस टाइमर का अनुरोध करते हैं, तो कॉलबैक एक अनलोड सिस्टम पर लगभग 20 एमएस के बाद शुरू होगा। यदि आपको एक ध्वज सेट करने की आवश्यकता है जो 30 फ्रेम प्रति सेकंड (प्रत्येक 33 एमएस) की गति से फ्रेम को अपडेट करने का संकेत देता है, तो आप 30 एमएस के लिए एक टाइमर सेट कर सकते हैं (नीचे उदाहरण देखें)। यदि आप इस फ़ंक्शन का उपयोग करते हैं, तो आपको SDL_INIT_TIMER को SDL_Init पास करना होगा।

जोड़े गए टाइमर के लिए पहचानकर्ता मान लौटाता है, या कोई त्रुटि होने पर NULL।

कॉलबैक के लिए प्रारूप:

Uint32 callback ( Uint32, void * param)

int SDL_CondSignal(SDL_cond *cond)

धागे के लिए इंतज़ार कर में से एक को पुनः प्रारंभ करने cond हालत चर । सफलता पर 0 और त्रुटि पर -1 देता है।

int SDL_CondWait(SDL_cond *cond, SDL_mutex *mut);

प्रदान किए गए म्यूटेक्स को अनलॉक करें और एक और थ्रेड के लिए प्रतीक्षा करें SDL_CondSignal या SDL_CondBroadcast को कॉन्ड कंडीशन चर के लिए कॉल करें, फिर म्यूटेक्स को फिर से लॉक करें। इस फ़ंक्शन को दर्ज करने से पहले म्यूटेक्स को लॉक किया जाना चाहिए। जब संकेत प्राप्त होता है, तो 0 या त्रुटि पर -1 लौटता है।

SDL_cond *SDL_CreateCond(void);

एक शर्त चर बनाता है।

SDL_Thread *SDL_CreateThread(int (*fn)(void *), void *data);

SDL_CreateThread निष्पादन का एक नया सूत्र बनाता है जो अपने माता-पिता, सिग्नल हैंडलर, फ़ाइल डिस्क्रिप्टर आदि की संपूर्ण वैश्विक मेमोरी को साझा करता है। और यह fn फ़ंक्शन चलाता है , इसे शून्य पॉइंटर डेटा पास करता है। जब कोई मान लौटाता है तो थ्रेड समाप्त हो जाता है।

void SDL_Delay (Uint32 );

मिलीसेकंड की निर्दिष्ट संख्या की प्रतीक्षा करता है। SDL_Delay कम से कम निर्दिष्ट समय की प्रतीक्षा करेगा, लेकिन संभवतः OS योजना के कारण।
नोट: कम से कम 10 एमएस की देरी ग्रैन्युलैरिटी की उम्मीद करें। कुछ प्लेटफार्मों में छोटे उपाय हैं, लेकिन यह सबसे आम विकल्प है।

SDL_Overlay *SDL_CreateYUVOverlay(int width, int height, Uint32 format, SDL_Surface *display);

SDL_CreateYUVOverlay प्रदत्त प्रदर्शन के लिए निर्दिष्ट चौड़ाई, ऊंचाई और प्रारूप (उपलब्ध प्रारूपों की सूची के लिए, SDL_Overlay डेटा संरचना देखें) का YUV ओवरले बनाता है। SDL_Overlay देता है।

प्रदर्शन वास्तव में SDL_SetVideoMode से प्राप्त सतह होना चाहिए, अन्यथा यह फ़ंक्शन डिफ़ॉल्ट रूप से काम करेगा।

"ओवरले" शब्द गलत है, क्योंकि यदि ओवरले हार्डवेयर में नहीं बनाया गया है, तो ओवरले प्रदर्शित होने पर उस क्षेत्र के नीचे डिस्प्ले सतह की सामग्री को ओवरले प्रदर्शित किया जाएगा।

int SDL_LockYUVOverlay(SDL_Overlay *overlay)

SDL_LockYUVOverlay पिक्सेल डेटा तक सीधी पहुंच के लिए ओवरले को ब्लॉक करता है। सफलता पर 0 या त्रुटि पर -1 मिलता है।

void SDL_UnlockYUVOverlay(SDL_Overlay *overlay)

पहले से बंद ओवरले को अनलॉक करता है। ओवरले को प्रदर्शित होने से पहले अनलॉक किया जाना चाहिए।

int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect)

जब यह बनाया गया था तो सतह पर ओवरले को डालता है। SDL_Rect dstrect संरचना गंतव्य की स्थिति और आकार को परिभाषित करती है। यदि dstrect अधिक या कम ओवरले है, तो ओवरले को स्केल किया जाएगा, यह 2x स्केलिंग के लिए अनुकूलित है। 0 सफल होने पर लौटाता है।

void SDL_FreeYUVOverlay(SDL_Overlay *overlay)

SDL_CreateYUVOverlay द्वारा बनाए गए ओवरले को रिलीज़ करता है।

int SDL_Init(Uint32 flags);

एसडीएल को प्रारंभ करता है। इसे अन्य सभी एसडीएल कार्यों से पहले बुलाया जाना चाहिए। झंडे पैरामीटर निर्दिष्ट करता है कि एसडीएल के कौन से हिस्से को इनिशियलाइज़ करना है।

SDL_INIT_TIMER - टाइमर सबसिस्टम को इनिशियलाइज़ करता है।
SDL_INIT_AUDIO - ऑडियो सबसिस्टम को इनिशियलाइज़ करता है।
SDL_INIT_VIDEO - वीडियो सबसिस्टम को इनिशियलाइज़ करता है।
SDL_INIT_CDROM - CD-ROM सबसिस्टम को इनिशियलाइज़ करता है।
SDL_INIT_JOYSTICK - जॉयस्टिक सबसिस्टम को इनिशियलाइज़ करता है।
SDL_INIT_EVERYTHING - उपरोक्त सभी को प्रारंभ करता है।
SDL_INIT_NOPARACHUTE - SDL को घातक त्रुटियों को पकड़ने की अनुमति नहीं देता है।
SDL_INIT_EVENTTHREAD - इवेंट मैनेजर को एक अलग थ्रेड में लॉन्च करता है।

त्रुटि पर -1 या सफलता पर 0 देता है। आप SDL_GetError पर कॉल करके एक विस्तारित त्रुटि संदेश प्राप्त कर सकते हैं। त्रुटि का एक विशिष्ट कारण सबसिस्टम के लिए इसी समर्थन के बिना एक विशिष्ट प्रदर्शन का उपयोग है, उदाहरण के लिए, डिवाइस के साथ एक फ्रेम बफर का उपयोग करते समय माउस ड्राइवर की अनुपस्थिति। इस स्थिति में, आप या तो माउस के बिना SDL संकलित कर सकते हैं, या एप्लिकेशन शुरू करने से पहले पर्यावरण चर "SDL_NOMOUSE = 1" सेट कर सकते हैं।

SDL_mutex *SDL_CreateMutex(void);

एक नया, खुला म्यूटेक्स बनाता है।

int SDL_LockMutex(SDL_mutex *mutex)

SDL_LockMutex SDL_mutexP के लिए एक अन्य नाम है। यह एक म्यूटेक्स को ब्लॉक करता है जिसे पहले SDL_CreateMutex का उपयोग करके बनाया गया था। यदि म्यूटेक्स पहले से ही किसी अन्य थ्रेड द्वारा अवरोधित किया गया है, तो SDL_mutexP तब तक कोई मान नहीं लौटाता है जब तक कि उसके द्वारा अवरुद्ध थ्रेड इसे अनलॉक नहीं करता (SDL_mutexV का उपयोग करके)। जब म्यूटेक्स को फिर से कहा जाता है, तो SDL_mutexV (उर्फ SDL_UnlockMutex) को म्यूटेक्स को अनलॉक किए गए राज्य में वापस करने के लिए बराबर बार कहा जाना चाहिए। सफलता पर 0 या त्रुटि पर -1 मिलता है।

int SDL_UnlockMutex(SDL_Mutex *mutex)

म्यूटेक्स अनलॉक।

int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)

यह फ़ंक्शन आवश्यक मानदंड के साथ ऑडियो यूनिट को खोलता है और 0 सफल होने पर रिटर्न देता है, वास्तविक हार्डवेयर मापदंडों को उस संरचना में रखता है जिसे वह अंततः इंगित करता है। यदि कोई NULL मान प्राप्त होता है, तो कॉलबैक फ़ंक्शन को पास किए गए ऑडियो डेटा को आवश्यक प्रारूप की गारंटी दी जाएगी और यदि आवश्यक हो, तो स्वचालित रूप से हार्डवेयर ऑडियो प्रारूप में परिवर्तित हो जाएगा। यदि ऑडियो डिवाइस को खोला नहीं जा सका या ऑडियो स्ट्रीम कॉन्फ़िगर नहीं किया जा सका तो यह फ़ंक्शन -1 देता है।

ऑडियो डिवाइस खोलने के लिए, आपको वांछित SDL_AudioSpec बनाने की आवश्यकता है। फिर आपको वांछित ऑडियो विनिर्देशों के साथ इस संरचना को भरना होगा।

वांछित-> फ्रीक : प्रति सेकंड नमूनों में वांछित ध्वनि आवृत्ति।
वांछित-> प्रारूप : वांछित ऑडियो प्रारूप (SDL_AudioSpec देखें)।
वांछित-> चैनल: आवश्यक चैनल (मोनो के लिए 1, स्टीरियो के लिए 2, सराउंड साउंड के लिए 4, सेंटरिंग और LFE के साथ चारों ओर ध्वनि के लिए 6)।
वांछित-> नमूने : नमूनों में वांछित ऑडियो बफर आकार। यह संख्या दो की शक्ति होनी चाहिए और ऑडियो ड्राइवर द्वारा हार्डवेयर के लिए अधिक उपयुक्त मूल्य पर समायोजित की जा सकती है। इष्टतम मान 512 से 8192 तक के होते हैं, जो अनुप्रयोग और प्रोसेसर की गति पर निर्भर करता है। छोटे मानों का परिणाम तेजी से प्रतिक्रिया समय में होता है, लेकिन खराब प्रदर्शन हो सकता है यदि एप्लिकेशन भारी प्रसंस्करण करता है और समय पर ऑडियो बफर नहीं भर सकता है। एलआर क्रम में स्टीरियो सैंपल में दाएं और बाएं चैनल होते हैं। कृपया ध्यान दें कि नमूनों की संख्या सीधे निम्नलिखित सूत्र का उपयोग करते हुए समय से संबंधित है: एमएस = (नमूने * 1000) / freq है ।
वांछित-> कॉलबैक : एक फ़ंक्शन पर सेट किया जाना चाहिए जिसे तब बुलाया जाएगा जब ऑडियो यूनिट अतिरिक्त डेटा प्राप्त करने के लिए तैयार हो। ऑडियो बफर के सूचक और ऑडियो बफर के बाइट्स में लंबाई प्रेषित होती है। इस फ़ंक्शन को आमतौर पर एक अलग थ्रेड में निष्पादित किया जाता है, और इसलिए कोड में SDL_LockAudio और SDL_UnlockAudio को कॉल करके इसे एक्सेस करने वाले डेटा संरचनाओं की सुरक्षा करना आवश्यक है। कॉलबैक प्रोटोटाइप है शून्य कॉलबैक ( शून्य * userdata , Uint8 * धारा , पूर्णांक लेन ) । userdata - userdata क्षेत्र SDL_AudioSpec में संग्रहीत एक सूचक। धाराऑडियो बफर के लिए एक संकेतक है जिसे आप जानकारी से भरना चाहते हैं, और बाइट में ऑडियो बफर की लंबाई लेन है।
आवश्यक-> उपयोगकर्ताडेटा : यह सूचक कॉलबैक फ़ंक्शन के पहले पैरामीटर के रूप में पारित किया गया है।

SDL_OpenAudio फ़ंक्शन से पारित वांछित SDL_AudioSpec संरचना से इन फ़ील्ड्स को पढ़ता है और आपकी इच्छा से मेल खाने वाले ऑडियो कॉन्फ़िगरेशन को खोजने का प्रयास करता है। जैसा कि ऊपर उल्लेख किया गया है, यदि परिणामी पैरामीटर NULL है, तो SDL को प्लेबैक के दौरान वांछित ध्वनि सेटिंग्स से उपकरण सेटिंग्स में परिवर्तित किया जाता है।

यदि NULL वापस किया जाता है, तो आवश्यक SDL_AudioSpec आपके कार्य विनिर्देश है, अन्यथा परिणामस्वरूप SDL_AudioSpec एक कार्य विनिर्देश बन जाता है, और वांछित विनिर्देश हटाया जा सकता है। डाउनलोड किए गए डेटा को उपकरण प्रारूप में परिवर्तित करने के लिए SDL_AudioCVT का निर्माण करते समय कार्य विनिर्देश में डेटा का उपयोग किया जाता है।

SDL_OpenAudio वांछित और परिणामी विनिर्देश दोनों के लिए आकार और मौन क्षेत्रों की गणना करता है। आकार फ़ील्ड ऑडियो बफ़र के कुल आकार को बाइट्स में संग्रहीत करता है, जबकि मौन भंडार को ऑडियो बफ़र में मौन का प्रतिनिधित्व करने के लिए उपयोग किया जाता है

जब यह खुला होता है तो साउंड डिवाइस खामोशी से बजना शुरू कर देता है और जब आप ऑडियो कॉलबैक फ़ंक्शन को कॉल करने के लिए तैयार होते हैं तो SDL_PauseAudio (0) को कॉल करके प्लेबैक के लिए चालू होना चाहिए। चूंकि ऑडियो ड्राइवर ऑडियो बफर के अनुरोधित आकार को बदल सकता है, इसलिए आपको ऑडियो डिवाइस खोलने के बाद किसी भी स्थानीय मिक्सर बफ़र्स का चयन करना होगा।

void SDL_PauseAudio(int pause_on)

यह फ़ंक्शन रुक जाता है और ऑडियो कॉलबैक प्रोसेसिंग को रोक देता है। ध्वनि चलाने के लिए ऑडियो डिवाइस खोलने के बाद इसे pause_on = 0 के साथ बुलाया जाना चाहिए। यह आपको ऑडियो यूनिट खोलने के बाद कॉलबैक फ़ंक्शन के लिए डेटा को सुरक्षित रूप से आरंभ करने की अनुमति देता है। एक ठहराव के दौरान ऑडियो डिवाइस पर मौन रिकॉर्ड किया जाएगा।

int SDL_PushEvent(SDL_Event *event)

एक घटना कतार जो वास्तव में दो-तरफ़ा संचार चैनल के रूप में उपयोग की जाती है। न केवल घटनाओं को कतार से पढ़ा जा सकता है, बल्कि उपयोगकर्ता अपनी स्वयं की घटनाओं को भी इसमें डाल सकता है। एक ईवेंट ईवेंट की संरचना का एक संकेतक है जिसे आप कतार में रखना चाहते हैं। ईवेंट को कतार में कॉपी किया जाता है, और कॉलर SDL_PushEvent को वापस करने के बाद इंगित की गई मेमोरी को प्रबंधित कर सकता है। यह फ़ंक्शन थ्रेड-ओरिएंटेड है और इसे अन्य थ्रेड्स से सुरक्षित रूप से कॉल किया जा सकता है। 0 सफल होने पर रिटर्न, या -1 अगर इवेंट को नहीं भेजा जा सकता है।

int SDL_WaitEvent(SDL_Event *event)

अगली उपलब्ध घटना के लिए अनिश्चित काल तक प्रतीक्षा करता है, 0 यदि घटनाओं की प्रतीक्षा करते समय कोई त्रुटि हुई है, तो 1 अन्यथा। यदि ईवेंट NULL नहीं है, तो अगला ईवेंट कतार से निकाल दिया जाता है और इस क्षेत्र में संग्रहीत किया जाता है।

void SDL_Quit()

सभी एसडीएल उपतंत्रों को निष्क्रिय करता है और इसके लिए आवंटित संसाधनों को मुक्त करता है। इसे हमेशा बाहर निकलने से पहले बुलाया जाना चाहिए।

SDL_Surface *SDL_SetVideoMode(int width, int height, int bitsperpixel, Uint32 flags)

निर्दिष्ट चौड़ाई, ऊंचाई और पिक्सेल बिट्स के साथ वीडियो मोड सेटिंग। एसडीएल 1.2.10 से शुरू, अगर चौड़ाई और ऊंचाई 0 है, तो यह वर्तमान वीडियो मोड की चौड़ाई और ऊंचाई (या डेस्कटॉप मोड यदि मोड सेट नहीं है) का उपयोग करेगा। यदि बिटस्पेरिक्सल 0 है, तो इसे वर्तमान प्रदर्शन बिट्स प्रति पिक्सेल के रूप में माना जाता है। झंडे पैरामीटर SDL_Surface संरचना के झंडे क्षेत्र के समान है। या निम्नलिखित मानों का एक संयोजन:

SDL_SWSURFACE - सिस्टम मेमोरी में एक वीडियो सतह बनाएं।
SDL_HWSURFACE - वीडियो मेमोरी में एक वीडियो सतह बनाएं।
SDL_ASYNCBLIT - प्रदर्शन सतह पर अतुल्यकालिक अपडेट के उपयोग को सक्षम करें। यह आमतौर पर सिंगल-प्रोसेसर कंप्यूटर पर काम धीमा कर देता है, लेकिन एसएमपी सिस्टम में गति बढ़ा सकता है।
SDL_ANYFORMAT - आमतौर पर, यदि प्रति पिक्सेल (बिट्स प्रति बिट पिक्सेल से) अनुरोधित बिट्स के साथ एक वीडियो सतह उपलब्ध नहीं है, तो SDL एक छायांकित सतह के साथ वीडियो का अनुकरण करेगा। SDL_ANYFORMAT पास करना इसे रोकता है और SDL को वीडियो की सतह का उपयोग करने के लिए बाध्य करता है, भले ही इसकी पिक्सेल में गहराई हो।
SDL_HWPALETTE - पैलेट के लिए SDL अनन्य पहुँच प्रदान करें। इस ध्वज के बिना, आप हमेशा SDL_SetColors या SDL_SetPalette का उपयोग करके आपके द्वारा अनुरोधित रंग प्राप्त नहीं कर सकते।
SDL_DOUBLEBUF - हार्डवेयर डबल बफरिंग सक्षम करें; केवल SDL_HWSURFACE के साथ मान्य है। SDL_Flip के लिए एक कॉल बफ़र्स को उलट देगा और स्क्रीन को ताज़ा करेगा। सभी ड्राइंग एक सतह पर जगह लेंगे जो वर्तमान में प्रदर्शित नहीं है। यदि डबल बफ़रिंग सक्षम नहीं किया जा सकता है, तो SDL_Flip केवल SDL_UpdateRect पूर्ण स्क्रीन निष्पादित करेगा।
SDL_FULLSCREEN SDL - पूर्ण स्क्रीन मोड का उपयोग करने का प्रयास करें। यदि हार्डवेयर रिज़ॉल्यूशन बदलना संभव नहीं है (किसी भी कारण से), अगले उच्च रिज़ॉल्यूशन का उपयोग किया जाएगा, और डिस्प्ले विंडो एक काले रंग की पृष्ठभूमि पर केंद्रित होगी।
SDL_OPENGL - एक OpenGL रेंडरिंग संदर्भ बनाएँ। यह माना जाता है कि SDL_GL_SetAttribute के साथ OpenGL वीडियो विशेषताएँ पहले से निर्धारित हैं।
SDL_OPENGLBLIT - जैसा कि ऊपर बताया गया है, एक OpenGL रेंडरिंग संदर्भ बनाएँ, लेकिन सामान्य ब्लटिंग ऑपरेशन की अनुमति दें। स्क्रीन की सतह (2D) में एक अल्फा चैनल हो सकता है, और स्क्रीन की सतह के परिवर्तनों को अपडेट करने के लिए SDL_UpdateRects का उपयोग किया जाना चाहिए। ध्यान दें। यह विकल्प केवल संगतता के लिए सहेजा गया है और भविष्य के संस्करणों में हटा दिया जाएगा। नए कोड में उपयोग के लिए अनुशंसित नहीं है।
SDL_RESIZABL- एक resizable विंडो को बनाएँ। जब उपयोगकर्ता द्वारा विंडो का आकार बदला जाता है, तो SDL_VIDEORESIZE घटना उत्पन्न होती है, और SDL_SetVideoMode को फिर से एक नए आकार के साथ बुलाया जा सकता है।
SDL_NOFRAME यदि संभव हो, तो SDL_NOFRAME SDL को बिना शीर्षक या फ़्रेमयुक्त विंडो बनाने के लिए बाध्य करता है। यह ध्वज स्वचालित रूप से पूर्ण स्क्रीन मोड में सेट किया गया है।
ध्यान दें। कोई फर्क नहीं पड़ता कि SDL_SetVideoMode झंडे संतुष्ट कर सकते हैं, वे लौटे सतह के तत्व तत्व में सेट हैं।
ध्यान दें। बिट पिक्सेल 24 प्रति पिक्सेल 3 बाइट्स के पैक्ड प्रतिनिधित्व का उपयोग करता है। प्रति पिक्सेल मोड में अधिक सामान्य 4 बाइट के लिए, 32 बिट पिक्सेल का उपयोग करें। विचित्र रूप से पर्याप्त, 15 और 16 दोनों एक पिक्सेल प्रति 2 बाइट का अनुरोध करेंगे, लेकिन विभिन्न पिक्सेल प्रारूपों के साथ।
ध्यान दें। यदि आप अलग पिक्सेल जोड़तोड़ करने या अल्फा चैनल का उपयोग करके सतहों को खींचने की योजना के लिए SDL_SWSURFACE का उपयोग करते हैं और उच्च फ्रेम दर की आवश्यकता होती है। जब आप हार्डवेयर सतहों (SDL_HWSURFACE) का उपयोग करते हैं, तो SDL उन सतहों को वीडियो मेमोरी से सिस्टम मेमोरी में कॉपी करता है जब आप उन्हें लॉक करते हैं और जब आप उन्हें अनलॉक करते हैं तो वापस। इससे प्रदर्शन में उल्लेखनीय कमी आ सकती है। (ध्यान रखें कि आप हार्डवेयर सतह के लिए क्वेरी कर सकते हैं, लेकिन फिर भी एक सॉफ़्टवेयर सतह प्राप्त कर सकते हैं। कई प्लेटफ़ॉर्म केवल SDL_FULLSCREEN का उपयोग करते समय एक हार्डवेयर सतह प्रदान कर सकते हैं।) SDL_HWSURFACE का सबसे अच्छा उपयोग किया जाता है जब आपके द्वारा सोची गई सतहों को वीडियो मेमोरी में भी संग्रहीत किया जा सकता है।
ध्यान दें। यदि आप विंडो की सतह बनाते समय स्क्रीन पर स्थिति को नियंत्रित करना चाहते हैं, तो आप पर्यावरण चर "SDL_VIDEO_CENTERED = केंद्र" या "SDL_VIDEO_WINDOW_POS" x, y "सेट करके ऐसा कर सकते हैं। आप उन्हें SDL_putenv के माध्यम से स्थापित कर सकते हैं।

वापसी मूल्य: विफलता के मामले में बफर बफर सतह या NULL। लौटी हुई सतह को SDL_Quit द्वारा मुक्त किया जाता है और कॉलर द्वारा मुक्त नहीं किया जाना चाहिए।
ध्यान दें। इस नियम में SDL_SetVideoMode (यानी, आकार बदलना) के लिए लगातार कॉल शामिल हैं - मौजूदा सतह स्वचालित रूप से मुक्त हो जाएगी।

परिशिष्ट 2. डेटा सरंचनाएं ← ⇑ →

AVCodecContext

AVStream-> कोडेक से स्ट्रीम से कोडेक के बारे में सभी जानकारी। कुछ महत्वपूर्ण गुण:

AVRational time_base : फ्रेम प्रति सेकंड
इंट नमूना_रेट : नमूने प्रति सेकंड
इंट चैनल : चैनलों की संख्या

पूरी सूची (बहुत प्रभावशाली) यहाँ देखें ( वेब संग्रह, क्योंकि मूल लिंक पहले से ही मौजूद नहीं है )। कई मापदंडों का उपयोग मुख्य रूप से एन्कोडिंग के लिए किया जाता है, डिकोडिंग के लिए नहीं।

AVFormatContext

डेटा फ़ील्ड:

const AVClass * av_class
AVInputFormat * iformat
AVOutputFormat * oformat
शून्य * priv_data :
ByteIOContext pb : निम्न-स्तरीय हेरफेर के लिए उपयोग किया जाता है।
अहस्ताक्षरित int nb_streams : फ़ाइल में थ्रेड्स की संख्या।
AVStream * स्ट्रीम [MAX_STREAMS] : प्रत्येक स्ट्रीम का डेटा यहां संग्रहीत है।
चार फ़ाइलनाम [१०२०]: लेकिन इसके बिना (मूल- युगल में ) क्या है।

फ़ाइल जानकारी:
int64_t टाइमस्टैम्प :
चार शीर्षक [512]:
char लेखक [512]:
char Copyright [512]:
char टिप्पणी [512]:
char एल्बम [512]:
int वर्ष :
int track :
char शैली [३२]:

int ctx_flags :
संभावित मूल्य AVFMT_NOEDNUMBER, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_RAWPICT AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX
AVPacketList * packet_buffer : इस बफर की जरूरत तभी पड़ती है जब पैकेट पहले से बफेड न हों लेकिन डिकोड न हों, उदाहरण के लिए, एमपीईजी स्ट्रीम में कोडेक पैरामीटर प्राप्त करने के लिए।
int64_tstart_time : जब डिकोडिंग: घटक के पहले फ्रेम की स्थिति, दूसरे के अंशों में, AV_TIME_BASE। इस मान को सीधे सेट न करें: यह AVStream के मानों से अनुमानित है।
int64_t अवधि: डिकोडिंग : धारा की अवधि, AV_TIME_BASE के अंशों में। इस मान को सीधे सेट न करें: यह AVStream के मानों से अनुमानित है।
int64_t file_size : कुल फ़ाइल आकार, 0 यदि अज्ञात है।
int bit_rate : डिकोडिंग: यदि उपलब्ध नहीं है, तो बिट / s, 0 में स्ट्रीम की कुल बिटरेट। कभी भी इसे सीधे सेट न करें अगर file_size और ffmpeg में ज्ञात अवधि इसे स्वचालित रूप से गणना कर सकती है।
AVStream * cur_st
const uint8_t * cur_ptr
int cur_len
AVPacket cur_pkt :
int64_t data_offset :
int index_built : पहले पैकेट की भरपाई।
पूर्णांक mux_rate :
पूर्णांक packet_size :
पूर्णांक प्रीलोड :
पूर्णांक max_delay :
पूर्णांक loop_output : समर्थित स्वरूपों में उत्पादन कई लूप के।
int ध्वज :
int loop_input :
अहस्ताक्षरित int probesize : डिकोडिंग: नमूना डेटा आकार; कोडिंग में उपयोग नहीं।
int max_analyze_duration : AV_TIME_BASE की इकाइयों में अधिकतम अवधि जिसके दौरान इनपुट डेटा का विश्लेषण av_find_stream_info ()
कॉन्स्ट uint8_t * कुंजी में किया जाना चाहिए :
int keylen :

AVIOContext

संसाधनों तक पहुँचने के लिए I / O संदर्भ।

const AVClass * av_class : निजी सेटिंग्स के लिए वर्ग।
अहस्ताक्षरित चार * बफर : बफर की शुरुआत।
int बफर_साइज : अधिकतम बफर आकार।
अहस्ताक्षरित चार * buf_ptr : बफर में वर्तमान स्थिति।
अहस्ताक्षरित चार * buf_end : डेटा बफ़र की तुलना में छोटा हो सकता है + बफ़र_साइज़ यदि रीड फ़ंक्शन अनुरोध के मुकाबले कम डेटा लौटाता है, उदाहरण के लिए।
शून्य * अपारदर्शी : निजी सूचक पढ़ने / लिखने / खोज करने के लिए उत्तीर्ण / ...
int (* read_packet) (शून्य * opaque, uint8_t * buf, int buf_size) :
int (* write_packet) (शून्य * opaque, uint8_t * buf, int buf_size ) :
int64_t (* seek) (शून्य * opaque, int64_t ऑफसेट, int
whence ) : int64_t pos : वर्तमान बफर की फाइल में स्थिति।
int must_flush : यदि अगली खोज रीसेट की जानी चाहिए तो सच है।
int eof_reached : फ़ाइल के अंत तक पहुँचने पर सच है।
int write_flag : यदि लेखन के लिए खुला है तो सच है।
int max_packet_size :
अहस्ताक्षरित लंबी चेकसम :
अहस्ताक्षरित चार *
चेकसम_प्ट्र : अहस्ताक्षरित लंबी (* अपडेट_चेकसम) (अहस्ताक्षरित लंबी चेकसम, कॉन्स्टेंट uint8_t * buf, अहस्ताक्षरित आकार) :
इंट त्रुटि : त्रुटि कोड या 0 यदि कोई त्रुटि नहीं हुई है।
int (* read_pause) (शून्य * अपारदर्शी, int ठहराव): नेटवर्क स्ट्रीमिंग प्रोटोकॉल के लिए प्लेबैक को रोकें या फिर से शुरू करें, उदाहरण के लिए।
int64_t (* read_seek) (शून्य * opaque, int stream_index, int64_t टाइमस्टैम्प, इंट फ्लैग) : निर्दिष्ट स्ट्रीम_index इंडेक्स के साथ स्ट्रीम में निर्दिष्ट टाइमस्टैम्प की खोज करें।
int खोजी : AVIO_SEEKABLE_ या 0 झंडे का संयोजन जब स्ट्रीम खोज योग्य नहीं है।
int64_t अधिकतम: चयन को सीमित करने के लिए अधिकतम फ़ाइल आकार। यह फ़ील्ड कामवासना के लिए आंतरिक है, और बाहर से इसे एक्सेस करना निषिद्ध है।
int direct : avio_read और avio_write को जब भी संभव हो सीधे निष्पादित किया जाना चाहिए, और बफर से नहीं गुजरना चाहिए, और avio_seek हमेशा सीधे मुख्य खोज फ़ंक्शन को कॉल करेगा।
int64_t बाइट्स_ड्रेड: बाइट आँकड़े पढ़ें यह क्षेत्र libavformat के लिए आंतरिक है और बाहरी पहुंच से वंचित है।
int seek_count : खोज आँकड़े। यह फ़ील्ड कामवासना के लिए आंतरिक है, और बाहर से इसे एक्सेस करना निषिद्ध है।
int writeout_count : आंकड़े लिखें। यह फ़ील्ड कामवासना के लिए आंतरिक है, और बाहर से इसे एक्सेस करना निषिद्ध है।
int Origin_buffer_size : बफर आकार को रीसेट करने के लिए जाँच करने और वापसी प्रदान करने के बाद मूल बफर आकार आंतरिक रूप से उपयोग किया जाता है। यह फ़ील्ड कामवासना के लिए आंतरिक है, और बाहर से इसे एक्सेस करना निषिद्ध है।

AVDictionary

Ffmpeg के मापदंडों को पास करने के लिए उपयोग किया जाता है।

int काउंट :
एवेरडेनेट्री * एलम्स :

AVDictionaryEntry

एवार्ड में शब्दकोश प्रविष्टियों को संग्रहीत करने के लिए प्रयुक्त।

char * ket :
char * value :

AVFrame

यह संरचना कोडेक के प्रकार पर निर्भर करती है और इसलिए इसे गतिशील रूप से निर्धारित किया जाता है। हालाँकि, इस संरचना के लिए सामान्य गुण और विधियाँ हैं:

uint8_t * डेटा [4] :
int लाइनें [4] : स्ट्राइड स्ट्राइड।
uint8_t * आधार [4] :
int key_frame :
int pict_type :
int64_t pts : ये वो pts नहीं हैं जिनकी आप डीकोडिंग करते समय अपेक्षा करते हैं।
int coded_picture_number :
int display_picture_number :
int गुणवत्ता :
int उम्र :
int संदर्भ :
int8_t * qscale_table :
int qstride :
uint8_t * mbskipiptable :
int16_t (* motion_val [2]) [2] [2]:
Uint32_t * mb_type :
uint8_t motion_subsample_log2 :
शून्य * अपारदर्शी : उपयोगकर्ता डेटा
uint64_t त्रुटि [4] :
पूर्णांक प्रकार :
पूर्णांक repeat_pict : निर्देश देता है आप छवि समय की एक निर्धारित संख्या को दोहराने के लिए।
int qscale_type :
int interlaced_frame :
int top_field_first :
AVPanScan * pan_scan :
int palette_has_changed :
int बफर_हिन्ट्स :
लघु * dct_coeff ,
int8_t * ref_index [2] :

AVPacket

वह संरचना जिसमें कच्चा पैकेट डेटा संग्रहीत किया जाता है। यह डेटा एक फ्रेम प्राप्त करने के लिए avcodec_decode_audio2 या avcodec_decode_video में स्थानांतरित किया जाना चाहिए।

int64_t pts : time_base इकाइयों में प्रस्तुति टाइमस्टैम्प।
int64_t dts : time_base की इकाइयों में अपघटन का समय टिकट।
uint8_t * डेटा : कच्चा डेटा।
int आकार : डेटा आकार।
int stream_index : AVFackatContext में मात्रा के आधार पर जिस स्ट्रीम से AVPacket आया था।
int झंडे : PKT_FLAG_KEY सेट है अगर पैकेट एक प्रमुख फ्रेम है।
int अवधि : time_base की इकाइयों में प्रस्तुति की अवधि (0 यदि उपलब्ध नहीं है)
शून्य (* डिस्ट्रक्ट) (स्ट्रक्चर एवीपैकेट *) : इस पैकेज के लिए रिसोर्स रिलीज फंक्शन (डिफ़ॉल्ट रूप से av_destruct_packet)।
शून्य * निजी :
int64_t पॉज़ : स्ट्रीम में बाइट की स्थिति, -1 यदि अज्ञात है।

AVPacketList

संकुल के लिए एक सरल लिंक की गई सूची।

AVPacket pkt :
AVPacketList * अगला :

AVPicture

यह संरचना पहले दो AVFrame डेटा तत्वों के समान है, इसलिए इसे अक्सर खारिज कर दिया जाता है। आमतौर पर एसडब्ल्यूएस कार्यों में उपयोग किया जाता है।

uint8_t * डेटा [4] :
इंट लाइन्स [4] : स्ट्रिंग में बाइट्स की संख्या।

AVRational

तर्कसंगत संख्याओं का प्रतिनिधित्व करने के लिए सरल संरचना।

int num : अंश।
int den : हर।

AVStream

धारा के लिए संरचना। आप इस जानकारी का उपयोग कोडेक में सबसे अधिक बार करने की संभावना रखते हैं।

पूर्णांक सूचकांक :
पूर्णांक आईडी :
AVCodecContext * कोडेक :
AVRational r_frame_rate :
शून्य * priv_data :
int64_t codec_info_duration :
पूर्णांक codec_info_nb_frames :
AVFrac अंक :
AVRational time_base :
पूर्णांक pts_wrap_bits :
पूर्णांक stream_copy :
एक enum छोड़ें AVDiscard आप संकुल कि दूर फेंक दिया जाएगा, क्योंकि वे की जरूरत नहीं है चुन सकते हैं: लोकतंत्र में
फ्लोट की गुणवत्ता :
int64_t start_time :
int64_t अवधि:
चार [4] भाषा :
पूर्णांक need_parsing : 1 -> पूर्ण पार्स, 2 की जरूरत है - केवल> पार्स हेडर, repacking बिना
AVCodecParserContext * पार्सर :
int64_t cur_dts :
पूर्णांक last_IP_duration :
int64_t last_IP_pts :
AVIndexEntry * index_entries :
पूर्णांक nb_index_entries :
एक अहस्ताक्षरित int index_entries_allocated_size :
int64_t nb_frames : इस धारा में फ़्रेमों की संख्या (यदि ज्ञात हो) या 0
int64_t pts_buffer [MAX_REORDER_DELAY + 1] :

ByteIOContext

एक संरचना जो मूवी फ़ाइल के बारे में निम्न-स्तरीय जानकारी संग्रहीत करती है।

अहस्ताक्षरित चार * बफर :
इंट बफर_साइज :
अहस्ताक्षरित चार * buf_ptr :
अहस्ताक्षरित चार * buf_end :
शून्य * अपारदर्शी :
int (* read_packet) (शून्य * अपारदर्शी, uinto_t * buf, int buf_size) :
int (* write_packet) (शून्य) uint8_t * buf, पूर्णांक buf_size) :
offset_t (* तलाश) (शून्य * अपारदर्शी, offset_t ऑफसेट, पूर्णांक जिस कारण से) :
स्थिति offset_t :
पूर्णांक must_flush :
पूर्णांक eof_reached :
पूर्णांक write_flag :
पूर्णांक is_streamed :
पूर्णांक max_packet_size :
अहस्ताक्षरित लंबी चेकसम :
अहस्ताक्षरित चार *
चेकसम_प्ट्र
: अहस्ताक्षरित लंबी (* अद्यतन_चेकसम) (अहस्ताक्षरित लंबी चेकसम: कॉन्स्ट uint8_t * buf, अहस्ताक्षरित int आकार) :
इंट त्रुटि : त्रुटि कोड या 0 होता है यदि कोई त्रुटि नहीं हुई है।

SDL_AudioSpec

कुछ ऑडियो डेटा के प्रारूप का वर्णन करने के लिए उपयोग किया जाता है।

freq : प्रति सेकंड नमूनों में ध्वनि आवृत्ति।
प्रारूप : ऑडियो डेटा प्रारूप।
चैनल : चैनलों की संख्या: 1 - मोनो, 2 - स्टीरियो, 4 सराउंड, 6 सराउंडिंग और LFE
साइलेंस के साथ : साउंड बफर की साइलेंस वैल्यू (गणना)।
नमूने : नमूनों में ऑडियो बफर आकार।
आकार : बाइट्स (गणना) में ऑडियो बफर का आकार।
कॉलबैक (..) : ऑडियो बफर को भरने के लिए कॉलबैक फ़ंक्शन।
userdata : उपयोगकर्ता डेटा के लिए एक पॉइंटर जो कॉलबैक फ़ंक्शन में जाता है।

निम्न प्रारूप मान

मान्य हैं : AUDIO_U8 - 8-बिट अहस्ताक्षरित नमूने।
AUDIO_S8 - 8-बिट नमूनों पर हस्ताक्षर किए।
AUDIO_U16 या AUDIO_U16LSB - सभी हार्डवेयर (अहस्ताक्षरित 16-बिट कम बाइट ऑर्डर) द्वारा समर्थित नहीं है।
AUDIO_S16 या AUDIO_S16LS - सभी हार्डवेयर (पुराने बाइट ऑर्डर के साथ 16-बिट)
द्वारा समर्थित नहीं है AUDIO_U16MSB - सभी हार्डवेयर (अहस्ताक्षरित 16-बिट बिग-एंडियन) द्वारा समर्थित नहीं है।
AUDIO_S16MS - सभी हार्डवेयर (उच्च बाइट ऑर्डर के साथ 16-बिट) द्वारा समर्थित नहीं है।
AUDIO_U16SYS: या तो AUDIO_U16LSB या AUDIO_U16MSB - हार्डवेयर प्रोसेसर पर निर्भर करता है।
AUDIO_S16SYS: या तो AUDIO_S16LSB या AUDIO_S16MSB - हार्डवेयर प्रोसेसर पर निर्भर करता है।

SDL_Event

घटनाओं के लिए बुनियादी संरचना।

प्रकार : घटना का प्रकार।
सक्रिय : सक्रियण घटना (SDL_ActiveEvent देखें)।
कुंजी : कीबोर्ड ईवेंट (SDL_KeyboardEvent देखें)।
गति : माउस आंदोलन घटना (SDL_MouseMotionEvent देखें)।
बटन : माउस क्लिक इवेंट (SDL_MouseButtonEvent देखें)।
jaxis : जॉयस्टिक एक्सिस मूवमेंट इवेंट (SDL_JoyAxisEvent देखें)।
jball : जॉयस्टिक ट्रैकबॉल मूवमेंट इवेंट (SDL_JoyBallEvent देखें)।
jhat : जॉयस्टिक हेडर मूवमेंट इवेंट (SDL_JoyHatEvent देखें)।
jbutton : जॉयस्टिक बटन दबाने की घटना (देखें SDL_JoyButtonEvent)।
आकार: अनुप्रयोग विंडो आकार परिवर्तन ईवेंट (SDL_ResizeEvent देखें)।
बेनकाब : आवेदन खिड़की खुली घटना (देखें SDL_ExposeEvent)।
छोड़ दिया : आवेदन निकास अनुरोध घटना (देखें SDL_QuitEvent)।
उपयोगकर्ता : उपयोगकर्ता घटना (SDL_UserEvent देखें)।
syswm : अपरिभाषित विंडो प्रबंधक घटना (SDL_SysWMEvent देखें)।

यहाँ घटनाओं के प्रकार हैं। अधिक जानकारी के लिए SDL दस्तावेज़ीकरण देखें:

SDL_ACTIVEEVENT SDL_ActiveEvent
SDL_KEYDOWN / UP SDL_KeyboardEvent
SDL_MOUSEMOTION SDL_MOUSEMOTION
कृपया देखें SDL_MOUTBUTTONDOWN / UP
SDL_KeyDownloadTe
SDL_ActiveEvent SDL_KEYDD
SDL_JoyHatEvent SDL_JOYHATMOTION
SDL_JOYBUTTONDOWN / यूपी SDL_JoyButtonEvent
SDL_VIDEORESIZE SDL_ResizeEvent
SDL_VIDEOEXPOSE SDL_ExposeEvent
SDL_Quit SDL_QuitEvent
SDL_USEREVENT SDL_UserEvent
SDL_SYSWMEVENT SDL_SysWMEvent

SDL_Overlay

YUV ओवरले।

प्रारूप : ओवरले प्रारूप (नीचे देखें)।
डब्ल्यू, एच : ओवरले की चौड़ाई / ऊंचाई।
विमानों : ओवरले की योजना की संख्या। आमतौर पर या तो 1 या 3.
पिचों : प्रत्येक योजना के लिए, एक इंडेंट की एक सरणी। इंडेंटेशन बाइट्स में स्ट्रिंग की लंबाई है।
पिक्सेल : प्रत्येक योजना के लिए डेटा पॉइंटर्स की एक सरणी। इन बिंदुओं का उपयोग करने से पहले ओवरले को लॉक किया जाना चाहिए।
hw_overlay : Overlay हार्डवेयर के त्वरित होने पर 1 पर सेट करें।

SDL_Rect

आयताकार क्षेत्र।

Sint16 x, y : आयत के ऊपरी बाएं कोने की स्थिति।
Uint16 w, h : आयत की चौड़ाई और ऊंचाई।

SDL_Rect पिक्सेल के एक आयताकार क्षेत्र को परिभाषित करता है। इसका उपयोग SDL_BlitSurface द्वारा ब्लिटिंग के क्षेत्रों और कुछ अन्य वीडियो सुविधाओं की पहचान करने के लिए किया जाता है।

SDL_Surface

बाहरी पक्ष (सतह) की ग्राफिक संरचना।

Uint32 झंडे : बाहरी stotrons के झंडे। केवल पढ़ने के लिए।
SDL_PixelFormat * प्रारूप : केवल-पढ़ने के लिए।
int w, h : चौड़ाई और ऊंचाई। केवल पढ़ने के लिए।
Uint16 पिच : कदम। केवल पढ़ने के लिए।
शून्य * पिक्सेल : वास्तविक पिक्सेल डेटा के लिए एक सूचक। केवल रिकॉर्डिंग के लिए।
SDL_Rect clip_rect : क्लिप के बाहर आयताकार। केवल पढ़ने के लिए।
int refcount : मेमोरी आवंटित करने के लिए उपयोग किया जाता है। ज्यादातर पढ़ने के लिए।
इस संरचना में वे निजी क्षेत्र भी शामिल हैं जो यहां नहीं दिखाए गए हैं

SDL_Surface "ग्राफिक" मेमोरी के एक क्षेत्र का प्रतिनिधित्व करता है जिसे खींचा जा सकता है। वीडियो बफर फ्रेम को SDL_SetVideoMode और SDL_GetVideoSurface का उपयोग करके SDL_Surface के रूप में लौटाया गया है। फ़ील्ड w और h पिक्सेल में सतह की चौड़ाई और ऊंचाई का प्रतिनिधित्व करने वाले मान हैं। पिक्सेल फ़ील्ड वास्तविक पिक्सेल डेटा का एक संकेतक है। नोट: इस क्षेत्र तक पहुँचने से पहले सतह को (SDL_LockSurface के माध्यम से) लॉक किया जाना चाहिए। क्लिप_ सही फ़ील्ड SDL_SetClipRect द्वारा सेट की गई आयत है।

ध्वज फ़ील्ड निम्न या मानों का समर्थन करता है:

SDL_SWSURFACE - बाहर सिस्टम मेमोरी में संग्रहीत है।
SDL_HWSURFACE - बाहरी पक्ष वीडियो मेमोरी में संग्रहीत किया जाता है।
SDL_ASYNCBLIT - यदि संभव हो तो बाहरी अतुल्यकालिक चकाचौंध का उपयोग करता है।
SDL_ANYFORMAT - किसी भी पिक्सेल प्रारूप (प्रदर्शन सतह) की अनुमति है।
SDL_HWPALETTE - सतह का एक विशेष पैलेट है।
SDL_DOUBLEBUF - डबल बफर सतह (प्रदर्शन सतह)।
SDL_FULLSCREEN - पूर्ण-स्क्रीन सतह (प्रदर्शन सतह)।
SDL_OPENGL - सतह में एक OpenGL संदर्भ (प्रदर्शन सतह) है।
SDL_OPENGLBLIT - सतह ओपनिंग (प्रदर्शन सतह) ब्लिंकिंग का समर्थन करती है। ध्यान दें। यह विकल्प केवल संगतता के लिए है और नए कोड के लिए अनुशंसित नहीं है।
SDL_RESIZABLE - आकार (प्रदर्शन सतह) के लिए आकार बदलना संभव है।
SDL_HWACCEL - सतह ब्लिट हार्डवेयर त्वरण का उपयोग करता है।
SDL_SRCCOLORKEY - सुपरफिशियलिटी कलर ब्लिटिंग का उपयोग करता है।
SDL_RLEACCEL - RLE के उपयोग से रंग निखरता है।
SDL_SRCALPHA - सरफेस ब्लिथ अल्फा सम्मिश्रण का उपयोग करता है।
SDL_PREALLOC - सतह पूर्व-आवंटित मेमोरी का उपयोग करती है।

SDL_Thread

यह संरचना स्वतंत्र है, और शायद आपको इसका उपयोग करने की आवश्यकता नहीं है। अधिक जानकारी के लिए स्रोत कोड में src / thread / sdl_thread_c.h देखें।

SDL_cond

यह संरचना स्वतंत्र है, और शायद आपको इसका उपयोग करने की आवश्यकता नहीं है। अधिक जानकारी के लिए स्रोत कोड में src / thread / <system> /SDL_syscond.c देखें।

SDL_mutex

यह संरचना स्वतंत्र है, और शायद आपको इसका उपयोग करने की आवश्यकता नहीं है। अधिक जानकारी के लिए स्रोत कोड में src / thread / <system> /SDL_sysmutex.c देखें।