int evdev_open(const struct hw_module_t* module, const char* id, struct hw_device_t** device) {
#ifdef DEBUG
	LOGE("evdev_open");
#endif
	if(strcmp(id, SENSORS_HARDWARE_CONTROL)==0) {
#ifdef DEBUG
		LOGE("evdev_open hw ctl");
#endif
		struct sensors_control_device_t *dev;
		*device=malloc(sizeof(struct sensors_control_device_t));
		memset(*device, 0, sizeof(struct sensors_control_device_t));
		(*device)[0].tag=HARDWARE_DEVICE_TAG;
		(*device)[0].version=0;
		(*device)[0].module=module;
		(*device)[0].close=evdev_close;
		dev=*device;

		dev[0].open_data_source=open_data_source;
		dev[0].activate=activate;
		dev[0].set_delay=set_delay;
		dev[0].wake=wake;
		int i;
		if(sFD<0)
			sFD=open_input();
		if(sFD<0)
			return -1;
#ifdef DEBUG
		LOGE("evdev_open hw ctl returning ok");
#endif
		return 1;
	} else if(strcmp(id, SENSORS_HARDWARE_DATA)==0) {
#ifdef DEBUG
		LOGE("evdev_open hw data");
#endif
		struct sensors_data_device_t *dev;
		*device=malloc(sizeof(struct sensors_data_device_t));
		memset(*device, 0, sizeof(struct sensors_data_device_t));
		(*device)[0].tag=HARDWARE_DEVICE_TAG;
		(*device)[0].version=0;
		(*device)[0].module=module;
		(*device)[0].close=evdev_close;
		dev=*device;

		dev[0].data_open=data_open;
		dev[0].data_close=data_close;
		dev[0].poll=data_poll;
		if(sFD<0)
			sFD=open_input();
#ifdef DEBUG
		LOGE("evdev_open hw data returning ok");
#endif
		return 1;
	} else {
		//Hu ?
		return -1;//Or 0?
	}
}
Esempio n. 2
0
int main(int argc, char** argv)
{
	if(argc < 2) // insuficient arguments
		exit(1);

	if(!open_input(argv[1])) // couldn't open input file
		exit(1);

	initMe();

	yyparse();

	initSemanticAnalyzer();
	first_pass(root);
	verify(root);

	int eCount = getErrorCount();

	if(eCount > 0)
	{
		fprintf(stderr,"%d semantic errors\n", eCount);

		exit(3);
	}

	close_input();

	exit(0);
}
Esempio n. 3
0
void InputThread::ctrl_open_input(const FXString & uri) {
  GM_DEBUG_PRINT("[input] ctrl_open_input %s\n",uri.text());

  if (uri.empty()) {
    goto failed;
    }

  /// Open Input
  input=open_input(uri);
  if (input==NULL) {
    engine->post(new ErrorMessage(FXString::value("Unable to open %s",uri.text())));
    goto failed;
    }

  reader = open_reader();
  if (reader==NULL) {
    engine->post(new ErrorMessage(FXString::value("No input plugin available for %s",uri.text())));
    goto failed;
    }

  if (!reader->init(input)) {
    engine->post(new ErrorMessage(FXString::value("Failed to initialize plugin")));
    goto failed;
    }

  streamid++;
  set_state(StateProcessing,true);
  return;
failed:
  ctrl_close_input();
  set_state(StateIdle,true);
  }
Esempio n. 4
0
static void
l_output(char *infile, char *define, int extend, char *outfile)
{
    char *include;
    definition *def;
    int foundprogram;
    char *outfilename;

    open_input(infile, define);
    outfilename = extend ? extendfile(infile, outfile) : outfile;
    open_output(infile, outfilename);
    f_print(fout, "#include <rpc/rpc.h>\n");
    f_print(fout, "#include <sys/time.h>\n");
    if (infile && (include = extendfile(infile, ".h"))) {
	f_print(fout, "#include \"%s\"\n", include);
	free(include);
    }
    foundprogram = 0;
    while ((def = get_definition())) {
	foundprogram |= (def->def_kind == DEF_PROGRAM);
    }
    if (extend && !foundprogram) {
	(void)unlink(outfilename);
	return;
    }
    write_stubs();
}
Esempio n. 5
0
/*
 * Compile into an RPC service
 */
static void
s_output(int argc, char *argv[], char *infile, char *define, int extend,
	 char *outfile, int nomain)
{
    char *include;
    definition *def;
    int foundprogram;
    char *outfilename;

    open_input(infile, define);
    outfilename = extend ? extendfile(infile, outfile) : outfile;
    open_output(infile, outfilename);
    f_print(fout, "#include <stdio.h>\n");
    f_print(fout, "#include <rpc/rpc.h>\n");
    if (infile && (include = extendfile(infile, ".h"))) {
	f_print(fout, "#include \"%s\"\n", include);
	free(include);
    }
    foundprogram = 0;
    while ((def = get_definition())) {
	foundprogram |= (def->def_kind == DEF_PROGRAM);
    }
    if (extend && !foundprogram) {
	(void)unlink(outfilename);
	return;
    }
    if (nomain) {
	write_programs(NULL);
    } else {
	write_most();
	do_registers(argc, argv);
	write_rest();
	write_programs("static");
    }
}
Esempio n. 6
0
int mpl_read_data(MPL *mpl, char *file)
{     if (mpl->phase != 1)
         fault("mpl_read_data: invalid call sequence");
      if (file == NULL)
         fault("mpl_read_data: no input filename specified");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* process data section */
      mpl->phase = 2;
      print("Reading data section from %s...", file);
      mpl->flag_d = 1;
      open_input(mpl, file);
      /* in this case the keyword 'data' is optional */
      if (is_literal(mpl, "data"))
      {  get_token(mpl /* data */);
         if (mpl->token != T_SEMICOLON)
            error(mpl, "semicolon missing where expected");
         get_token(mpl /* ; */);
      }
      data_section(mpl);
      /* process end statement */
      end_statement(mpl);
      print("%d line%s were read", mpl->line, mpl->line == 1 ? "" : "s")
         ;
      close_input(mpl);
done: /* return to the calling program */
      return mpl->phase;
}
/*
 * generate the dispatch table
 */
static void
t_output (char *infile, char *define, int extend, char *outfile)
{
  definition *def;
  int foundprogram = 0;
  char *outfilename;
  char *incfile;

  open_input (infile, define);
  outfilename = extend ? extendfile (infile, outfile) : outfile;
  incfile = extendfile (infile, ".h");
  open_output (infile, outfilename);

  add_warning ();
  f_print (fout, "#include \"%s\"\n", incfile);

  while ((def = get_definition ())) {
    foundprogram |= (def->def_kind == DEF_PROGRAM);
  }
  if (extend && !foundprogram) {
    (void) unlink (outfilename);
    return;
  }
  write_tables ();
}
Esempio n. 8
0
void InputThread::ctrl_open_inputs(const FXStringList & urls){
  for (FXint i=0;i<urls.no();i++){
    GM_DEBUG_PRINT("[input] ctrl_open_inputs[%d] %s\n",i,urls[i].text());
    if (urls[i].empty()) continue;

    /// Open Input
    input=open_input(urls[i]);
    if (input==NULL) {
      if (aborted()) break;
      continue;
      }

    /// Open Reader
    reader = open_reader();
    if (reader==NULL) continue;

    if (!reader->init(input))
      continue;

    streamid++;
    set_state(StateProcessing,true);
    return;
    }
  ctrl_close_input();
  set_state(StateIdle,true);
  }
Esempio n. 9
0
static void
c_output(const char *infile, const char *define, int extend, const char *outfile)
{
	definition *def;
	char *include;
	const char *outfilename;
	long tell;

	c_initialize();
	open_input(infile, define);
	outfilename = extend ? extendfile(infile, outfile) : outfile;
	open_output(infile, outfilename);
	add_warning();
	if (infile && (include = extendfile(infile, ".h"))) {
		f_print(fout, "#include \"%s\"\n", include);
		free(include);
		/* .h file already contains rpc/rpc.h */
	} else
		f_print(fout, "#include <rpc/rpc.h>\n");
	tell = ftell(fout);
	while ( (def = get_definition()) )
		emit(def);
	if (extend && tell == ftell(fout))
		unlink(outfilename);
}
Esempio n. 10
0
static int open_camera(struct camera *cam) {
  int ret = 0, v_st_i;
  AVDictionary *opts = NULL;

  if((ret = av_dict_set(&opts, "rtsp_transport", "tcp", 0)) < 0) {
    av_err_msg ("av_dict_set", ret);
    return -1;
  }

  cam->context = avformat_alloc_context();
  snprintf(cam->context->filename, sizeof(cam->context->filename), "%s", cam->url);
  cam->context->interrupt_callback.callback = &interrupt_callback;
  cam->context->interrupt_callback.opaque = cam;
  cam->last_io = time(NULL);

  if((v_st_i = open_input(cam->context, &opts)) < 0)
    return -1;

  cam->video_stream_index = v_st_i;
  cam->input_stream = cam->context->streams[cam->video_stream_index];
  cam->codec = cam->input_stream->codec;
  av_dict_free(&opts);

  return 0;
}
Esempio n. 11
0
static int
local_init (struct shdec * dec, char *input_filename, char *output_filename)
{
	/* Open input/output stream */
	dec->input_fd = dec->output_fd = -1;
	if (input_filename != NULL && open_input(dec, input_filename))
		return -50;
	if (output_filename != NULL && open_output(dec, output_filename))
		return -51;

	/* Allocate memory for input buffer */
	dec->input_buffer = malloc(dec->max_nal_size);
	if (dec->input_buffer == NULL)
		return -1;

	if (dec->input_fd != -1) {
		/* Fill input buffer */
		if ((dec->si_isize = read(dec->input_fd, dec->input_buffer, dec->max_nal_size)) <= 0) {
			perror(input_filename);
			return -54;
		}
	}

	return 0;
}
Esempio n. 12
0
int AudioALSA::read_buffer(char *buffer, int size)
{
//printf("AudioALSA::read_buffer 1\n");
	int attempts = 0;
	int done = 0;

	if(!get_input())
	{
		sleep(1);
		return 0;
	}

	while(attempts < 1 && !done)
	{
		if(snd_pcm_readi(get_input(), 
			buffer, 
			size / (device->in_bits / 8) / device->get_ichannels()) < 0)
		{
			printf("AudioALSA::read_buffer overrun at sample %" PRId64 "\n",
				device->total_samples_read);
//			snd_pcm_resume(get_input());
			close_input();
			open_input();
			attempts++;
		}
		else
			done = 1;
	}
	return 0;
}
Esempio n. 13
0
static int tp_cmd_execute(CmdInterface* thiz, void* ctx)
{
	DECLES_PRIV(priv, thiz);
	char content[4];
	int fd;

	fd = open_input(SPRD_TS_INPUT_DEV, O_RDONLY);
	Parcel* reply = parcel_create();

	parcel_set_main_cmd(reply, DIAG_AUTOTEST_F);
	parcel_set_sub_cmd(reply, AUTOTEST_TP);

	memset(content, 0, sizeof(content));
	if (fd > 0) {
		*(uint8_t*)(content) = AUTOTEST_RET_PASS;
		close(fd);
	} else {
		*(uint8_t*)(content) = AUTOTEST_RET_FAIL;
	}

	parcel_set_content(reply, content, 4);

	cmd_listener_reply(priv->listener, reply);
	parcel_destroy(reply);

	return 0;
}
Esempio n. 14
0
File: teepot.c Progetto: dkj/teepot
int main(int argc, char** argv) {
  Opts    options;
  int     out_start = argc;
  Input   in = { 0, -1, 0 };
  Output *outputs = malloc((argc - 1) * sizeof(Output));
  int    *regular = malloc((argc - 1) * sizeof(int));
  int    *pipes   = malloc((argc - 1) * sizeof(int));
  SpillControl spillage = { NULL, NULL, NULL, NULL,
			    0, 0, 0, 0, 0, 0, 0, 0 };  /* Spillage info. */
  int     nregular = 0, npipes = 0;
  struct sigaction sig;

  if (NULL == outputs || NULL == regular || NULL == pipes) {
    perror("malloc");
    return EXIT_FAILURE;
  }

  /* Ignore SIGPIPEs, we want write(2) to get EPIPE instead. */
  sig.sa_handler = SIG_IGN;
  if (0 != sigaction(SIGPIPE, &sig, NULL)) {
    perror("sigaction");
    return EXIT_FAILURE;
  }

  if (0 != get_options(argc, argv, &options, &out_start)) {
    return EXIT_FAILURE;
  }

  if (verbosity > 0) {
    fprintf(stderr, "%.3f Started.\n", get_time());
  }

  if (0 != open_input(&options, &in, &spillage)) {
    return EXIT_FAILURE;
  }

  if (out_start >= argc) {
    fprintf(stderr, "No output files specified\n");
    return EXIT_FAILURE;
  }

  /* Open the output files */
  if (open_outputs(argc - out_start, argv + out_start, outputs,
		   regular, pipes, &nregular, &npipes) != 0) {
    return EXIT_FAILURE;
  }
  
  /* Copy input to all outputs */
  if (do_copy(&options, &in, argc - out_start, outputs,
	      nregular, regular, npipes, pipes, &spillage) != 0) {
    return EXIT_FAILURE;
  }

  if (verbosity > 0) {
    fprintf(stderr, "%.3f Finished.\n", get_time());
  }

  return EXIT_SUCCESS;
}
Esempio n. 15
0
// Open both input and output in ESD
int AudioESound::open_duplex()
{
	device->duplex_channels = 2;
	device->duplex_bits = 16;
	open_input();
	open_output();
	return 0;
}
static native_handle_t* sensors_control_open_data_source(struct sensors_control_device_t *dev)
{
    LOGI("sensors_control_open_data_source");

    native_handle * nh = native_handle_create(1, 0);
    nh->data[0] = open_input();
    return nh;
}
Esempio n. 17
0
bool do_copy_file(compilation_env_t *env, compilation_unit_t *unit)
{
	if (!open_input(unit))
		return false;
	if (!open_output(env))
		return false;
	copy_file(env->out, unit->input);
	close_output(env);
	return close_input(unit);
}
Esempio n. 18
0
int main(int argc, char** argv)
{
    int ret = EXIT_SUCCESS;

    /* Initialize param struct to zero */
    memset(&P, 0, sizeof(P));

    if (!parse_input(argc, argv)) {
        return EXIT_FAILURE;
    }

    /* Initialize parameters corresponding to YUV-format */
    setup_param();

    if (!sdl_init()) {
        return EXIT_FAILURE;
    }

    if (!open_input()) {
        return EXIT_FAILURE;
    }

    if (!allocate_memory()) {
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* Lets do some basic consistency check on input */
    check_input();

    /* send event to display first frame */
    event.type = SDL_KEYDOWN;
    event.key.keysym.sym = SDLK_RIGHT;
    SDL_PushEvent(&event);

    /* while true */
    event_loop();

cleanup:
    destroy_message_queue();
    SDL_FreeYUVOverlay(my_overlay);
    free(P.raw);
    free(P.y_data);
    free(P.cb_data);
    free(P.cr_data);
    if (fd) {
        fclose(fd);
    }
    if (P.fd2) {
        fclose(P.fd2);
    }

    return ret;
}
Esempio n. 19
0
int main(int argc, char *argv[])
{
	struct input_state	in = { };
	int			fd_out;
	char const		*event_filename = NULL;
	int			rc;
	int			repeat_params[2] = { 250 ,100 };

	for (;;) {
		int	c;

		c = getopt_long(argc, argv, "e:D:R:", CMDLINE_OPTIONS, NULL);
		if (c == -1)
			break;

		switch (c) {
		case 'k':
			rc = read_keymap(optarg);
			if (rc != EX_OK)
				return rc;
			break;

		case 'D':
			repeat_params[0] = atoi(optarg);
			break;

		case 'R':
			repeat_params[1] = atoi(optarg);
			break;

		default:
			fprintf(stderr, "unknown option\n");
			return EX_USAGE;
		}
	}

	if (argc < optind + 1) {
		fprintf(stderr, "missing parameters\n");
		return EX_USAGE;
	} else {
		event_filename = argv[optind + 0];
	}

	if (!open_input(&in, event_filename, repeat_params))
		return EX_OSERR;

	fd_out = open_uinput(&in);
	if (fd_out < 0)
		return EX_OSERR;

	while (handle_input(&in, fd_out))
		;
}
Esempio n. 20
0
int main(int argc, char ** argv) {
   if (argc == 1 || argc > 3) {
      print_usage();
      printf("Error: invalid number of parameters!\n");
      exit(1);
   } else if (argc == 3) {
      serverName = argv[2];  // get UDP server's IP address
   }
   platName = argv[1];  // get mote platform's name
   open_input();
   if (serverName != NULL) setup_socket();
   while(1){
	read_forward();
   }
}
Esempio n. 21
0
static void* tp_test_thread(void* ptr)
{
	TestCase* thiz = (TestCase*)ptr;
	DECLES_PRIV(priv, thiz);

	fd_set rfds;
	struct input_event event;
	struct timeval timeout;
	int n;
	int max_points = SPRD_WIDTH_POINTS * 2 + SPRD_HEIGHT_POINTS * 2 - 4;

	int ts_fd = open_input(SPRD_TS_INPUT_DEV, O_RDONLY);
	if (ts_fd < 0) {
		LOGE("%s: fail to get input dev %s", __func__, SPRD_TS_INPUT_DEV);
		return NULL;
	}

	timeout.tv_sec = 3;
	timeout.tv_usec = 0;

	while(priv->thread_run == 1) {
		if (tp_test_check_all_keys(thiz) == max_points) {
			priv->ts_success = 1;
			tp_test_show(thiz);
			break;
		}

		FD_ZERO(&rfds);
		FD_SET(ts_fd, &rfds);

		n = select(ts_fd + 1, &rfds, NULL, NULL, &timeout);
		if (n < 0) {
			LOGE("%s: select ts input error: (%s)", __func__,
					strerror(errno));
		}

		if (FD_ISSET(ts_fd, &rfds)) {
			n = read(ts_fd, &event, sizeof(event));	
			if (n == sizeof(event)) {
				tp_test_handle_event(thiz, &event);
			}
		} else {
			//LOGE("%s: fd is not set", __func__);
		}
	}

	return NULL;
}
Esempio n. 22
0
int main(int argc, char* argv[])
{
	int ret;

	av_register_all();
	av_log_set_level(AV_LOG_DEBUG);

	if(argc < 2)
	{
		printf("usage : %s <input>\n", argv[0]);
		return 0;
	}

	if(open_input(argv[1]) < 0)
	{
		goto main_end;
	}

	// AVPacket은 코덱으로 압축된 스트림 데이터를 저장하는데 사용됩니다.
	AVPacket pkt;

	while(1)
	{
		ret = av_read_frame(input_ctx.fmt_ctx, &pkt);
		if(ret == AVERROR_EOF)
		{
			// 더 이상 읽어올 패킷이 없습니다.
			printf("End of frame\n");
			break;
		}

		if(pkt.stream_index == input_ctx.v_index)
		{
			printf("Video packet\n");
		}
		else if(pkt.stream_index == input_ctx.a_index)
		{
			printf("Audio packet\n");
		}

		av_free_packet(&pkt);
	} // while

main_end:
	release();

	return 0;
}
Esempio n. 23
0
int mpl_read_model(MPL *mpl, char *file, int skip_data)
{     if (mpl->phase != 0)
         xfault("mpl_read_model: invalid call sequence\n");
      if (file == NULL)
         xfault("mpl_read_model: no input filename specified\n");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* translate model section */
      mpl->phase = 1;
      xprintf("Reading model section from %s...\n", file);
      open_input(mpl, file);
      model_section(mpl);
      if (mpl->model == NULL)
         error(mpl, "empty model section not allowed");
      /* save name of the input text file containing model section for
         error diagnostics during the generation phase */
      mpl->mod_file = xcalloc(strlen(file)+1, sizeof(char));
      strcpy(mpl->mod_file, mpl->in_file);
      /* allocate content arrays for all model objects */
      alloc_content(mpl);
      /* optional data section may begin with the keyword 'data' */
      if (is_keyword(mpl, "data"))
      {  if (skip_data)
         {  warning(mpl, "data section ignored");
            goto skip;
         }
         mpl->flag_d = 1;
         get_token(mpl /* data */);
         if (mpl->token != T_SEMICOLON)
            error(mpl, "semicolon missing where expected");
         get_token(mpl /* ; */);
         /* translate data section */
         mpl->phase = 2;
         xprintf("Reading data section from %s...\n", file);
         data_section(mpl);
      }
      /* process end statement */
      end_statement(mpl);
skip: xprintf("%d line%s were read\n",
         mpl->line, mpl->line == 1 ? "" : "s");
      close_input(mpl);
done: /* return to the calling program */
      return mpl->phase;
}
Esempio n. 24
0
/*
 * Seed PRNG using randomness from file
 * Assume file contains at least RANDOM_BYTES_NEEDED 'random' bytes
 */
u32 SeedPRNGfromFile (const u8 *rfile, RANDOM_STRUCT *r)
{
  FILE *fp;
  u32 n=RANDOM_BYTES_NEEDED;
  u32 bytes;
  u8 *buffer;

  if (r == NULL) return PRNG_NOT_INIT;
  if ( (fp = (FILE *)open_input(rfile)) == NULL) {
    exit(1);
  }
  
  if ( (buffer = (u8 *)malloc(RANDOM_BYTES_NEEDED)) == NULL) {
        fprintf(stderr, "error in SeedPRNGfromFile: out of memory.\n");
        exit (1); 
  }

  while (GetRandomBytesNeeded (&n, r) > 0) {
    if ( (bytes = fread (buffer, 1, n, fp)) < n ) {
      if ( ferror(fp) ) {
        fprintf(stderr, "error while reading randomness file '%s' : %s\n", 
                rfile, strerror(errno));
        exit (1); 
      } 
      if ( feof(fp) ) {
        fprintf(stderr, 
	   "error: not enough bytes in file '%s' to seed PRNG.\n", rfile);
        fprintf(stderr, "(bytes expected: %d, bytes read: %d).\n",
	   RANDOM_BYTES_NEEDED, bytes);
        exit (1); 
      } 
      fprintf(stderr, "error in SeedPRNGfromFile: unkown error\n");
      exit (1); 
    }
    RandomUpdate (r, buffer, bytes);
  }

  /* zeroize sensitive information */
  memset (buffer, 0, RANDOM_BYTES_NEEDED);

  free (buffer);
  fclose(fp);
}
Esempio n. 25
0
        DeckLinkInputAdapter(unsigned int card_index = 0,
                unsigned int norm_ = 0, unsigned int input_ = 0,
                RawFrame::PixelFormat pf_ = RawFrame::CbYCrY8422,
                bool enable_audio = false) 
                : deckLink(NULL), out_pipe(IN_PIPE_SIZE) {

            audio_pipe = NULL;

            pf = pf_;
            bpf = convert_pf(pf_);

            deckLink = find_card(card_index);
            select_input_connection(input_);
            open_input(norm_);

            if (enable_audio) {
                n_channels = 2;
                select_audio_input_connection( );
                open_audio_input( );
            }

            start_capture( );
        }
Esempio n. 26
0
        DeckLinkInputAdapter(unsigned int card_index = 0,
                unsigned int norm_ = 0, unsigned int input_ = 0,
                RawFrame::PixelFormat pf_ = RawFrame::CbYCrY8422,
                bool enable_audio = false, unsigned int n_channels = 2,
                bool enable_video = true)
                : deckLink(NULL), out_pipe(IN_PIPE_SIZE) {

            audio_pipe = NULL;
            started = false;
            signal_lost = false;
            rotate = false;
            this->enable_video = enable_video;

            n_frames = 0;
            start_time = 0;
            avsync = 0;
            drop_audio = 0;

            pf = pf_;
            bpf = convert_pf(pf_);

            deckLink = find_card(card_index);
            select_input_connection(input_);
            open_input(norm_);

            if (enable_audio) {
                audio_pipe = new Pipe<IOAudioPacket *>(IN_PIPE_SIZE);
            }

            this->n_channels = n_channels;
            select_audio_input_connection( );
            open_audio_input( );


            start_capture( );

        }
Esempio n. 27
0
int main(int argc, char **argv)
{
    static m4af_io_callbacks_t m4af_io = {
        read_callback, write_callback, seek_callback, tell_callback
    };
    aacenc_param_ex_t params = { 0 };

    int result = 2;
    char *output_filename = 0;
    pcm_reader_t *reader = 0;
    HANDLE_AACENCODER encoder = 0;
    AACENC_InfoStruct aacinfo = { 0 };
    m4af_ctx_t *m4af = 0;
    const pcm_sample_description_t *sample_format;
    int frame_count = 0;
    int sbr_mode = 0;
    unsigned scale_shift = 0;

    setlocale(LC_CTYPE, "");
    setbuf(stderr, 0);

    if (parse_options(argc, argv, &params) < 0)
        return 1;

    if ((reader = open_input(&params)) == 0)
        goto END;

    sample_format = pcm_get_format(reader);

    sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)&params);
    if (sbr_mode && !aacenc_is_sbr_ratio_available()) {
        fprintf(stderr, "WARNING: Only dual-rate SBR is available "
                        "for this version\n");
        params.sbr_ratio = 2;
    }
    scale_shift = aacenc_is_dual_rate_sbr((aacenc_param_t*)&params);
    params.sbr_signaling =
        (params.transport_format == TT_MP4_LOAS) ? 2 :
        (params.transport_format == TT_MP4_RAW)  ? 1 : 0;
    if (sbr_mode && !scale_shift)
        params.sbr_signaling = 2;

    if (aacenc_init(&encoder, (aacenc_param_t*)&params, sample_format,
                    &aacinfo) < 0)
        goto END;

    if (!params.output_filename) {
        const char *ext = params.transport_format ? ".aac" : ".m4a";
        output_filename = generate_output_filename(params.input_filename, ext);
        params.output_filename = output_filename;
    }

    if ((params.output_fp = aacenc_fopen(params.output_filename, "wb+")) == 0) {
        aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.output_filename,
                       strerror(errno));
        goto END;
    }
    handle_signals();

    if (!params.transport_format) {
        uint32_t scale;
        unsigned framelen = aacinfo.frameLength;
        scale = sample_format->sample_rate >> scale_shift;
        if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io,
                                params.output_fp)) < 0)
            goto END;
        m4af_set_decoder_specific_info(m4af, 0,
                                       aacinfo.confBuf, aacinfo.confSize);
        m4af_set_fixed_frame_duration(m4af, 0,
                                      framelen >> scale_shift);
        m4af_set_vbr_mode(m4af, 0, params.bitrate_mode);
        m4af_set_priming_mode(m4af, params.gapless_mode + 1);
        m4af_begin_write(m4af);
    }
Esempio n. 28
0
int main(int argc, char **argv)
{
    int i;

    if(argc == 1) {
        usage();
        return 1;
    }

    parse_options(argc,argv);

    if(!quiet)
        version();

    if(optind >= argc) {
        fprintf(stderr, _("ERROR: No input files specified. Use -h for help\n"));
        return 1;
    }

    if(argc - optind > 1 && outfilename && !raw) {
        fprintf(stderr, _("ERROR: Can only specify one input file if output filename is specified\n"));
        return 1;
    }

    if(outfilename && raw) {
        FILE *infile, *outfile;
        char *infilename;

        if(!strcmp(outfilename, "-")) {
            free(outfilename);
            outfilename = NULL;
        }
        outfile = open_output(outfilename);

        if(!outfile)
            return 1;

        for(i=optind; i < argc; i++) {
            if(!strcmp(argv[i], "-")) {
                infilename = NULL;
                infile = open_input(NULL);
            }
            else {
                infilename = argv[i];
                infile = open_input(argv[i]);
            }

            if(!infile) {
                fclose(outfile);
                free(outfilename);
                return 1;
            }
            if(decode_file(infile, outfile, infilename, outfilename)) {
                fclose(outfile);
                return 1;
            }

        }

        fclose(outfile);
    }
    else {
        for(i=optind; i < argc; i++) {
            char *in, *out;
            FILE *infile, *outfile;

            if(!strcmp(argv[i], "-"))
                in = NULL;
            else
                in = argv[i];

            if(outfilename) {
                if(!strcmp(outfilename, "-"))
                    out = NULL;
                else
                    out = outfilename;
            }
            else {
                char *end = strrchr(argv[i], '.');
                end = end?end:(argv[i] + strlen(argv[i]) + 1);

                out = malloc(strlen(argv[i]) + 10);
                strncpy(out, argv[i], end-argv[i]);
                out[end-argv[i]] = 0;
                if(raw)
                    strcat(out, ".raw");
                else
                    strcat(out, ".wav");
            }

            infile = open_input(in);
            if(!infile) {
                if(outfilename)
                    free(outfilename);
                return 1;
            }
            outfile = open_output(out);
            if(!outfile) {
                fclose(infile);
                return 1;
            }

            if(decode_file(infile, outfile, in, out)) {
                fclose(outfile);
                return 1;
            }

            if(!outfilename)
                free(out);

            fclose(outfile);
        }
    }

    if(outfilename)
        free(outfilename);

    return 0;
}
Esempio n. 29
0
int main(int argc, char *argv[])
{
	char *filename = read_opts(argc, argv);

	/* set up an rnn context */
	rnn_init();
	rnndb = rnn_newdb();
	rnn_parsefile(rnndb, "fifo/nv_objects.xml");
	if (rnndb->estatus)
		demmt_abort();
	rnn_prepdb(rnndb);
	domain = rnn_finddomain(rnndb, "SUBCHAN");
	if (!domain)
		demmt_abort();

	rnndb_g80_texture = rnn_newdb();
	rnn_parsefile(rnndb_g80_texture, "graph/g80_texture.xml");
	if (rnndb_g80_texture->estatus)
		demmt_abort();
	rnn_parsefile(rnndb_g80_texture, "graph/gm107_texture.xml");
	if (rnndb_g80_texture->estatus)
		demmt_abort();
	rnn_prepdb(rnndb_g80_texture);

	rnndb_gf100_shaders = rnn_newdb();
	rnn_parsefile(rnndb_gf100_shaders, "graph/gf100_shaders.xml");
	if (rnndb_gf100_shaders->estatus)
		demmt_abort();
	rnn_prepdb(rnndb_gf100_shaders);

	gf100_shaders_ctx = rnndec_newcontext(rnndb_gf100_shaders);
	gf100_shaders_ctx->colors = colors;
	/* doesn't matter which, just needs to exist to make it
	 * possible to modify later.
	 */
	rnndec_varadd(gf100_shaders_ctx, "GF100_SHADER_KIND", "FP");

	rnndb_nvrm_object = rnn_newdb();
	rnn_parsefile(rnndb_nvrm_object, "../docs/nvrm/rnndb/nvrm_object.xml");
	if (rnndb_nvrm_object->estatus)
		demmt_abort();
	rnn_prepdb(rnndb_nvrm_object);

	tic_domain = rnn_finddomain(rnndb_g80_texture, "TIC");
	tic2_domain = rnn_finddomain(rnndb_g80_texture, "TIC2");
	tsc_domain = rnn_finddomain(rnndb_g80_texture, "TSC");

	gf100_sp_header_domain = rnn_finddomain(rnndb_gf100_shaders, "GF100_SP_HEADER");
	gf100_fp_header_domain = rnn_finddomain(rnndb_gf100_shaders, "GF100_FP_HEADER");
	if (!gf100_sp_header_domain || !gf100_fp_header_domain)
		demmt_abort();

	gk104_cp_header_domain = rnn_finddomain(rnndb, "GK104_COMPUTE_LAUNCH_DESC");
	if (!gk104_cp_header_domain)
		demmt_abort();

	if (filename)
	{
		close(0);
		if (open_input(filename) == NULL)
		{
			perror("open");
			exit(1);
		}
		free(filename);
	}

	if (pager_enabled)
	{
		int pipe_fds[2];
		pid_t pid;

		if (pipe(pipe_fds) < 0)
		{
			perror("pipe");
			demmt_abort();
		}

		pid = fork();
		if (pid < 0)
		{
			perror("fork");
			demmt_abort();
		}

		if (pid > 0)
		{
			char *less_argv[] = { "less", "-ScR", NULL };

			close(pipe_fds[1]);
			dup2(pipe_fds[0], 0);
			close(pipe_fds[0]);
			execvp(less_argv[0], less_argv);

			perror("exec");
			demmt_abort();
		}

		close(pipe_fds[0]);
		dup2(pipe_fds[1], 1);
		dup2(pipe_fds[1], 2);
		close(pipe_fds[1]);
	}

#ifdef LIBSECCOMP_AVAILABLE
	if (seccomp_level)
	{
		int rc;
		scmp_filter_ctx ctx;
		if (seccomp_level == 2)
			ctx = seccomp_init(SCMP_ACT_KILL);
		else
			ctx = seccomp_init(SCMP_ACT_TRACE(1234));
		if (!ctx)
		{
			fprintf(stderr, "seccomp_init failed\n");
			exit(1);
		}

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 1,
				SCMP_A0(SCMP_CMP_EQ, 0));
		if (rc != 0)
			exit(1);
		seccomp_syscall_priority(ctx, SCMP_SYS(read), 254);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1,
				SCMP_A0(SCMP_CMP_LE, 2));
		if (rc != 0)
			exit(1);
		seccomp_syscall_priority(ctx, SCMP_SYS(write), 255);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 1,
				SCMP_A0(SCMP_CMP_EQ, 1));
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mremap), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
		if (rc != 0)
			exit(1);

		rc = seccomp_rule_add_exact(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 2,
				SCMP_A0(SCMP_CMP_EQ, 1),
				SCMP_A1(SCMP_CMP_EQ, 0x5401/*TCGETS*/));
		if (rc != 0)
			exit(1);

		rc = seccomp_load(ctx);
		if (rc != 0)
		{
			fprintf(stderr, "seccomp_load failed with error: %d\n", rc);
			exit(1);
		}

		seccomp_release(ctx);
	}
#endif

	mmt_decode(&demmt_funcs.base, NULL);
	fflush(stdout);

	fini_macrodis();
	demmt_cleanup_isas();
	rnndec_freecontext(gf100_shaders_ctx);
	rnn_freedb(rnndb);
	rnn_freedb(rnndb_g80_texture);
	rnn_freedb(rnndb_gf100_shaders);
	rnn_freedb(rnndb_nvrm_object);
	rnn_fini();

	return 0;
}
Esempio n. 30
0
static int read_data(void *opaque, uint8_t *buf, int buf_size)
{
    struct variant *v = opaque;
    HLSContext *c = v->parent->priv_data;
    int ret, i;

restart:
    if (!v->input) {
        /* If this is a live stream and the reload interval has elapsed since
         * the last playlist reload, reload the variant playlists now. */
        int64_t reload_interval = v->n_segments > 0 ?
                                  v->segments[v->n_segments - 1]->duration :
                                  v->target_duration;
        reload_interval *= 1000000;

reload:
        if (!v->finished &&
            av_gettime() - v->last_load_time >= reload_interval) {
            if ((ret = parse_playlist(c, v->url, v, NULL)) < 0)
                return ret;
            /* If we need to reload the playlist again below (if
             * there's still no more segments), switch to a reload
             * interval of half the target duration. */
            reload_interval = v->target_duration * 500000LL;
        }
        if (v->cur_seq_no < v->start_seq_no) {
            av_log(NULL, AV_LOG_WARNING,
                   "skipping %d segments ahead, expired from playlists\n",
                   v->start_seq_no - v->cur_seq_no);
            v->cur_seq_no = v->start_seq_no;
        }
        if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
            if (v->finished)
                return AVERROR_EOF;
            while (av_gettime() - v->last_load_time < reload_interval) {
                if (ff_check_interrupt(c->interrupt_callback))
                    return AVERROR_EXIT;
                av_usleep(100*1000);
            }
            /* Enough time has elapsed since the last reload */
            goto reload;
        }

        ret = open_input(v);
        if (ret < 0)
            return ret;
    }
    ret = ffurl_read(v->input, buf, buf_size);
    if (ret > 0)
        return ret;
    ffurl_close(v->input);
    v->input = NULL;
    v->cur_seq_no++;

    c->end_of_segment = 1;
    c->cur_seq_no = v->cur_seq_no;

    if (v->ctx && v->ctx->nb_streams && v->parent->nb_streams >= v->stream_offset + v->ctx->nb_streams) {
        v->needed = 0;
        for (i = v->stream_offset; i < v->stream_offset + v->ctx->nb_streams;
             i++) {
            if (v->parent->streams[i]->discard < AVDISCARD_ALL)
                v->needed = 1;
        }
    }
    if (!v->needed) {
        av_log(v->parent, AV_LOG_INFO, "No longer receiving variant %d\n",
               v->index);
        return AVERROR_EOF;
    }
    goto restart;
}