lqt_codecfile.c

这个库实现了录象功能

      /* We allocate memory here */
      if(codec->num_fourccs)
        {
        codec->fourccs = malloc(codec->num_fourccs * sizeof(char*));
        for(i = 0; i < codec->num_fourccs; i++)
          codec->fourccs[i] = malloc(5 * sizeof(char));
        }
      }
    
    /* Fourccs */
    
    else if(CHECK_KEYWORD(fourccs_key))
      {
      pos = line + strlen(fourccs_key);
      for(i = 0; i < codec->num_fourccs; i++)
        {
        tmp_fourcc = strtoul(pos, &rest, 16);
        LQT_FOURCC_2_STRING(codec->fourccs[i], tmp_fourcc);
        if(rest == pos)
          break;
        pos = rest;
        }
      }

    /* Number of wav ids */

    else if(CHECK_KEYWORD(num_wav_ids_key))
      {
      pos = line + strlen(num_wav_ids_key);
      codec->num_wav_ids = atoi(pos);

      /* We allocate memory here */
      
      codec->wav_ids = malloc(codec->num_wav_ids * sizeof(int));
      }

    /* Wav ids */
    
    else if(CHECK_KEYWORD(wav_ids_key))
      {
      pos = line + strlen(wav_ids_key);
      for(i = 0; i < codec->num_wav_ids; i++)
        {
        codec->wav_ids[i] = strtoul(pos, &rest, 16);
        pos = rest;
        }
      }
    
    /* Number of parameters */

    else if(CHECK_KEYWORD(num_encoding_parameters_key))
      {
      pos = line + strlen(num_encoding_parameters_key);
      codec->num_encoding_parameters = atoi(pos);
      if(codec->num_encoding_parameters)
        codec->encoding_parameters =
          calloc(codec->num_encoding_parameters,
                 sizeof(lqt_parameter_info_t));
      else
        codec->encoding_parameters =
          (lqt_parameter_info_t*)0;
      }
    else if(CHECK_KEYWORD(num_decoding_parameters_key))
      {
      pos = line + strlen(num_decoding_parameters_key);
      codec->num_decoding_parameters = atoi(pos);
      if(codec->num_decoding_parameters)
        codec->decoding_parameters =
          calloc(codec->num_decoding_parameters,
                 sizeof(lqt_parameter_info_t));
      else
        codec->decoding_parameters =
          (lqt_parameter_info_t*)0;
        
      }
    
    /* Read parameters */

    else if(CHECK_KEYWORD(begin_parameter_e_key))
      {
      read_parameter_info(input,
                          &(codec->encoding_parameters[encoding_parameters_read]),
                          line);
      encoding_parameters_read++;
      }

    else if(CHECK_KEYWORD(begin_parameter_d_key))
      {
      read_parameter_info(input,
                     &(codec->decoding_parameters[decoding_parameters_read]),
                     line);
      decoding_parameters_read++;
      }
    else if(CHECK_KEYWORD(end_codec_key))
      break;
    }
  
  }


lqt_codec_info_t * lqt_registry_read(char ** audio_order, char ** video_order)
  {
  FILE * input;
  char * line;
  char * pos = (char*)0;
  lqt_codec_info_t * ret =     (lqt_codec_info_t *)0;
  lqt_codec_info_t * ret_end = (lqt_codec_info_t *)0;
  
  if(*filename_buffer == '\0')
    create_filename();
  
  input = fopen(filename_buffer, "r");
 
  if(!input)
    {

    return (lqt_codec_info_t*)0;
    }
  
  line = malloc(READ_BUFFER_SIZE);
  
  while(1)
    {
    fgets(line, READ_BUFFER_SIZE-1, input);
    if(feof(input))
      break;
    pos = strchr(line, '\n');
    if(pos)
      *pos = '\0';

    pos = line;
        
    /* Skip comment lines */

    if(*pos == '#')
      continue;

    else if(CHECK_KEYWORD(audio_order_key))
      {
      if(audio_order)
        {
        pos += strlen(audio_order_key);
        *audio_order = __lqt_strdup(pos);
        }
      continue;
      }
    else if(CHECK_KEYWORD(video_order_key))
      {
      if(video_order)
        {
        pos += strlen(video_order_key);
        *video_order = __lqt_strdup(pos);
        }
      continue;
      }
    
    else if(CHECK_KEYWORD(begin_codec_key))
      {
      if(!ret_end)
        {
        ret = calloc(1, sizeof(lqt_codec_info_t));
        ret_end = ret;
        }
      else
        {
        ret_end->next = calloc(1, sizeof(lqt_codec_info_t));
        ret_end = ret_end->next;
        }
      read_codec_info(input, ret_end, pos);

      ret_end->next = (lqt_codec_info_t*)0;
      }
    }


  fclose(input);
  
  free(line);
  return ret;
  }

static void write_help_string(FILE * output, char * help_string)
  {
  int i, imax;
  fprintf(output, "%s", help_string_key);

  imax = strlen(help_string);
  for(i = 0; i < imax; i++)
    {
    if(help_string[i] == '\n')
      fprintf(output, "\\n");
    else
      fprintf(output, "%c", help_string[i]);
    }
  fprintf(output, "\n");
  }

static void write_parameter_info(FILE * output,
                                 const lqt_parameter_info_t * info,
                                 int encode)
  {
  const char * tmp = (const char*)0;
  int i;
  
  fprintf(output, "%s%s\n",
          (encode ? begin_parameter_e_key : begin_parameter_d_key),
          info->name);
  fprintf(output, "%s%s\n", real_name_key, info->real_name);
  switch(info->type)
    {
    case LQT_PARAMETER_INT:
      tmp = type_int;
      break;
    case LQT_PARAMETER_FLOAT:
      tmp = type_float;
      break;
    case LQT_PARAMETER_STRING:
      tmp = type_string;
      break;
    case LQT_PARAMETER_STRINGLIST:
      tmp = type_stringlist;
      break;
    case LQT_PARAMETER_SECTION:
      tmp = type_section;
      break;
    }

  fprintf(output, "%s%s\n", type_key, tmp);

  /*
   *   Print the value
   */
  
  switch(info->type)
    {
    case LQT_PARAMETER_INT:
      fprintf(output, "%s%d\n", value_key, info->val_default.val_int);

      if(info->val_min.val_int < info->val_max.val_int)
        {
        fprintf(output, "%s%d\n", min_value_key, info->val_min.val_int);
        fprintf(output, "%s%d\n", max_value_key, info->val_max.val_int);
        }

      break;
    case LQT_PARAMETER_FLOAT:
      fprintf(output, "%s%f\n", value_key, info->val_default.val_float);

      if(info->val_min.val_float < info->val_max.val_float)
        {
        fprintf(output, "%s%f\n", min_value_key, info->val_min.val_float);
        fprintf(output, "%s%f\n", max_value_key, info->val_max.val_float);
        }
      fprintf(output, "%s%d\n", num_digits_key, info->num_digits);
      break;
    case LQT_PARAMETER_STRING:
      fprintf(output, "%s%s\n", value_key, info->val_default.val_string);
      break;
    case LQT_PARAMETER_STRINGLIST:
      fprintf(output, "%s%s\n", value_key, info->val_default.val_string);

      /* 
       *  Print options
       */
      fprintf(output, "%s%d\n", num_options_key, info->num_stringlist_options);
      
      for(i = 0; i < info->num_stringlist_options; i++)
        fprintf(output, "%s%s\n", option_key, info->stringlist_options[i]);
      for(i = 0; i < info->num_stringlist_options; i++)
        fprintf(output, "%s%s\n", label_key, info->stringlist_labels[i]);
      break;
    case LQT_PARAMETER_SECTION:
      break;
    }

  if(info->help_string)
    {
    write_help_string(output, info->help_string);
    }
  
  fprintf(output, "%s\n", end_parameter_key);
    
  }

/* 
 *  Write codec info, return FALSE on error
 */ 

static int write_codec_info(const lqt_codec_info_t * info, FILE * output)
  {
  const char * tmp;

  int i;
  
  fprintf(output, "%s%s\n", begin_codec_key, info->name);
  fprintf(output, "%s%s\n", long_name_key, info->long_name);

  fprintf(output, "%s%s\n", description_key, info->description);

  tmp = NULL;
  
  switch(info->type)
    {
    case LQT_CODEC_AUDIO:
      tmp = type_audio;
      break;
    case LQT_CODEC_VIDEO:
      tmp = type_video;
      break;
    }

  if(tmp)
    fprintf(output, "%s%s\n", type_key, tmp);
  
  switch(info->direction)
    {
    case LQT_DIRECTION_DECODE:
      tmp = direction_decode;
      break;
    case LQT_DIRECTION_ENCODE:
      tmp = direction_encode;
      break;
    case LQT_DIRECTION_BOTH:
      tmp = direction_both;
      break;
    }

  if(tmp)
    fprintf(output, "%s%s\n", direction_key, tmp);

  fprintf(output, "%s%08x\n", compatibility_key, info->compatibility_flags);

  
  
  if(info->num_fourccs)
    {
    fprintf(output, "%s%d\n", num_fourccs_key, info->num_fourccs);
    
    fprintf(output, "%s", fourccs_key);
    
    for(i = 0; i < info->num_fourccs; i++)
      fprintf(output, "0x%08X ", LQT_STRING_2_FOURCC(info->fourccs[i]));
    fprintf(output, "\n");
    }
  
  if(info->num_wav_ids)
    {
    fprintf(output, "%s%d\n", num_wav_ids_key, info->num_wav_ids);
    fprintf(output, "%s", wav_ids_key);
    for(i = 0; i < info->num_wav_ids; i++)
      fprintf(output, "0x%02X ", info->wav_ids[i]);
    fprintf(output, "\n");
    }
  
  fprintf(output, "%s%d\n", num_encoding_parameters_key,
          info->num_encoding_parameters);

  for(i = 0; i < info->num_encoding_parameters; i++)
    {
    write_parameter_info(output, &(info->encoding_parameters[i]), 1);
    }

  fprintf(output, "%s%d\n", num_decoding_parameters_key,
          info->num_decoding_parameters);
    
  for(i = 0; i < info->num_decoding_parameters; i++)
    {
    write_parameter_info(output, &(info->decoding_parameters[i]), 0);
    }
 
  
  /* Module filename and index */
  fprintf(output, "%s%s\n", module_filename_key, info->module_filename);
  fprintf(output, "%s%d\n", module_index_key, info->module_index);
  fprintf(output, "%s%u\n", module_file_time_key, info->file_time);

  if(info->gettext_domain)
    fprintf(output, "%s%s\n", gettext_domain_key, info->gettext_domain);
  if(info->gettext_directory)
    fprintf(output, "%s%s\n", gettext_directory_key, info->gettext_directory);
  
  if(fprintf(output, "%s\n", end_codec_key) < 0)
    return 0;
  return 1;
  }

void lqt_registry_write()
  {
  int i;
  FILE * output;
  
  lqt_codec_info_t * codec_info;

  lqt_registry_lock();
  
  if(*filename_buffer == '\0')
    create_filename();

  
  output = fopen(filename_buffer, "w");
  
  if(!output)
    {
    lqt_registry_unlock();
    return;
    }

  /*
   *  Write initial comment
   */
  
  fprintf(output, "# This is the codec database file for libquicktime\n\
# It is automatically generated and should not be edited.\n\
# If you changed it and your libquicktime program doesn't work\n\
# anymore, delete it, and you will get a new one\n");

  /* Write the sort strings */

  if(lqt_num_audio_codecs)
    {
    codec_info = lqt_audio_codecs;
    
    fprintf(output, audio_order_key);
    for(i = 0; i < lqt_num_audio_codecs; i++)
      {
      fprintf(output, codec_info->name);
      if(i == lqt_num_audio_codecs - 1)
        fprintf(output, "\n");
      else
        fprintf(output, ",");
      codec_info = codec_info->next;
      }
    }

  if(lqt_num_video_codecs)
    {
    codec_info = lqt_video_codecs;
    fprintf(output, video_order_key);
    for(i = 0; i < lqt_num_video_codecs; i++)
      {
      fprintf(output, codec_info->name);
      if(i == lqt_num_video_codecs - 1)
        fprintf(output, "\n");
      else
        fprintf(output, ",");
      codec_info = codec_info->next;
      }
    }
  
  codec_info = lqt_audio_codecs;
  
  for(i = 0; i < lqt_num_audio_codecs; i++)
    {
    if(!write_codec_info(codec_info, output))
      goto fail;
    codec_info = codec_info->next;
    }

  codec_info = lqt_video_codecs;
  for(i = 0; i < lqt_num_video_codecs; i++)
    {
    if(!write_codec_info(codec_info, output))
      goto fail;
    codec_info = codec_info->next;
    }
  fclose(output);
  lqt_registry_unlock();

  return;
fail:
  fclose(output);
  lqt_registry_unlock();
  
  lqt_log(NULL, LQT_LOG_INFO, LOG_DOMAIN,
          "%s could not be written, deleting imcomplete file", filename_buffer);
  remove(filename_buffer);
  }