Starts the camera recording process.
513421
def start(self):
        
        self._started = True
        self._camera = _Camera(self._actual_camera, self._cmd_q, self._res, self._codec, self._fps, self._rate)
        self._camera.start()
1203113
def start(self):
        """"""
        response = api.request_syncmodule(self.blink,
                                          self.network_id,
                                          force=True)
        try:
            self.summary = response['syncmodule']
            self.network_id = self.summary['network_id']
        except (TypeError, KeyError):
            _LOGGER.error(("Could not retrieve sync module information "
                           "with response: %s"), response, exc_info=True)
            return False

        try:
            self.sync_id = self.summary['id']
            self.serial = self.summary['serial']
            self.status = self.summary['status']
        except KeyError:
            _LOGGER.error("Could not extract some sync module info: %s",
                          response,
                          exc_info=True)

        self.network_info = api.request_network_status(self.blink,
                                                       self.network_id)

        self.check_new_videos()
        try:
            for camera_config in self.camera_list:
                if 'name' not in camera_config:
                    break
                name = camera_config['name']
                self.cameras[name] = BlinkCamera(self)
                self.motion[name] = False
                camera_info = self.get_camera_info(camera_config['id'])
                self.cameras[name].update(camera_info,
                                          force_cache=True,
                                          force=True)
        except KeyError:
            _LOGGER.error("Could not create cameras instances for %s",
                          self.name,
                          exc_info=True)
            return False

        return True
1245657
def start(self):
        
        _log.debug('starting %s', self)
        self.started = True

        with _log_time('started %s', self):
            self.extensions.all.setup()
            self.extensions.all.start()
729462
def start_video_recording(self, local_video_file_path, video_filename):
        

        self.runner.info_log("Starting video recording...")

        self.local_video_recording_file_path = local_video_file_path
        self.remote_video_recording_file_path = video_filename

        self.execute_command(
            "./start_recording.sh '%s'" % self.remote_video_recording_file_path
        )
1249034
def start(self):
    """"""
    self.__run_backup = self.run
    self.run = self.__run      # Force the Thread to install our trace.
    threading.Thread.start(self)
146021
public void start() throws CameraAccessException, IOException, IllegalAccessException
    {
        if (mTryOpenCamera)
        {
            mCamera = openCamera();
            mCameraOwner = new GVRCameraSceneObject(getGVRContext(), mWidth / 2, mHeight / 2, mCamera);
            mCameraOwner.getTransform().setPositionZ(-200.0f);
            mTryOpenCamera = false;
        }
        if (isEnabled() && (mCamera != null))
        {
            mCamera.startPreview();
            if (!onStart())
            {
                throw new IllegalAccessException("Cannot access body tracker");
            }
        }
    }
862195
def start(self):
        """"""
        if self.stream is None:
            from pyaudio import PyAudio, paInt16
            self.pa = PyAudio()
            self.stream = self.pa.open(
                16000, 1, paInt16, True, frames_per_buffer=self.chunk_size
            )

        self._wrap_stream_read(self.stream)

        self.engine.start()
        self.running = True
        self.is_paused = False
        self.thread = Thread(target=self._handle_predictions)
        self.thread.daemon = True
        self.thread.start()
89877
def start(self):
        
        try:
            self._depth_align = False
            if self._registration_mode == RealSenseRegistrationMode.DEPTH_TO_COLOR:
                self._depth_align = True

            self._config_pipe()
            self._profile = self._pipe.start(self._cfg)

            # store intrinsics and depth scale
            self._set_depth_scale()
            self._set_intrinsics()

            # skip few frames to give auto-exposure a chance to settle
            for _ in range(5):
                self._pipe.wait_for_frames()

            self._running = True
        except RuntimeError as e:
            print(e)
635613
function start (startTiming) {
  if (isStart) {
    return
  }
  isStart = true
  recordTiming('MIPStart', startTiming)
  viewer.on('show', showTiming => {
    recordTiming('MIPPageShow', showTiming)
  })

  document.addEventListener('DOMContentLoaded', domLoaded, false)
  document.onreadystatechange = () => {
    if (document.readyState === 'complete') {
      domLoaded()
    }
  }
}
412207
public void start() {
    try {
      if (null == recorder) {
        recorder = new MediaRecorder();
        recorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
        recorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
        recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
        recorder.setOutputFile(this.localPath);
        recorder.prepare();
      } else {
        recorder.reset();
        recorder.setOutputFile(this.localPath);
      }
      recorder.start();
      startRecordTime = System.currentTimeMillis();
      if (null != this.listener) {
        this.listener.onStartRecord();
      }
    } catch (IOException ex) {
      LOGGER.e("failed to start MediaRecorder. cause: ", ex);
    }
  }
952833
def start_record():
    
    global record, playback, current
    if record:
        raise StateError("Already recording.")
    if playback:
        raise StateError("Currently playing back.")
    record = True
    current = ReplayData()
    install(RecordingHTTPConnection, RecordingHTTPSConnection)
1259080
private void startRecording(String line, DispatchCallback callback) {
    OutputFile outputFile = sqlLine.getRecordOutputFile();
    if (outputFile != null) {
      callback.setToFailure();
      sqlLine.error(sqlLine.loc("record-already-running", outputFile));
      return;
    }

    String filename;
    if (line.length() == "record".length()
        || (filename =
            sqlLine.dequote(line.substring("record".length() + 1))) == null) {
      sqlLine.error("Usage: record <file name>");
      callback.setToFailure();
      return;
    }

    try {
      outputFile = new OutputFile(expand(filename));
      sqlLine.setRecordOutputFile(outputFile);
      sqlLine.output(sqlLine.loc("record-started", outputFile));
      callback.setToSuccess();
    } catch (Exception e) {
      callback.setToFailure();
      sqlLine.error(e);
    }
  }
1008544
public final void start() {
    if (this.started) {
      log.warn(String.format("Reporter %s has already been started.", this.name));
      return;
    }
    try {
      startImpl();
      this.started = true;
    } catch (Exception exception) {
      log.warn(String.format("Reporter %s did not start correctly.", this.name), exception);
    }
  }
1131222
public void start() {
		if (LOG.isInfoEnabled()) {
			LOG.info("Esper statement [" + epl + "] being started");
		}

		this.epStatement.start();

		if (LOG.isInfoEnabled()) {
			LOG.info("Esper statement [" + epl + "] started");
		}
	}
915088
def run(self):
        
        if not self.camera.is_running:
            self.camera.start()
        while True:
            if not self.cmd_q.empty():
                cmd = self.cmd_q.get()
                if cmd[0] == 'stop':
                    self.out.close()
                    self.recording = False
                elif cmd[0] == 'start':
                    filename = cmd[1]
                    self.out = si.FFmpegWriter(filename)
                    self.recording = True
                    self.count = 0

            if self.recording:
                if self.count == 0:
                    image, _, _ = self.camera.frames()
                    
                    if self.data_buf is None:
                        self.data_buf = np.zeros([1, image.height, image.width, image.channels])
                    self.data_buf[0,...] = image.raw_data
                    self.out.writeFrame(self.data_buf)

                self.count += 1
                if self.count == self.rate:
                    self.count = 0
1041485
def start(self):
        # type: (Uploader) -> None
        
        try:
            blobxfer.operations.progress.output_parameters(
                self._general_options, self._spec)
            self._run()
        except (KeyboardInterrupt, Exception) as ex:
            if isinstance(ex, KeyboardInterrupt):
                logger.info(
                    'KeyboardInterrupt detected, force terminating '
                    'processes and threads (this may take a while)...')
            else:
                logger.exception(ex)
            self._wait_for_transfer_threads(terminate=True)
            self._wait_for_disk_threads(terminate=True)
        finally:
            # shutdown processes
            if self._md5_offload is not None:
                self._md5_offload.finalize_processes()
            if self._crypto_offload is not None:
                self._crypto_offload.finalize_processes()
            # close resume file
            if self._resume is not None:
                self._resume.close()
341835
function () {
            var self = this;

            // add all defined cameras
            this.settings.cameras.forEach(function(camera) {
                self.cameras.set(camera.name, camera);
            });

            // empty or no default camera
            if (this.cameras.has("default") === false) {
                if (typeof default_camera === "undefined") {
                    var width = me.video.renderer.getWidth();
                    var height = me.video.renderer.getHeight();
                    // new default camera instance
                    default_camera = new me.Camera2d(0, 0, width, height);
                }
                this.cameras.set("default", default_camera);
            }

            // reset the game manager
            me.game.reset();

            // call the onReset Function
            this.onResetEvent.apply(this, arguments);
        }