this is called on the context of the recording
169565
function (frames) {

        this.setFrames(frames);

        if (player.recording != this){
          console.log('recordings changed during load');
          return
        }

        // it would be better to use streamingCount here, but that won't be in until 0.5.0+
        // For now, it just flashes for a moment until the first frame comes through with a hand on it.
        // if (autoPlay && (controller.streamingCount == 0 || pauseOnHand)) {
        if (player.autoPlay) {
          player.play();
          if (player.pauseOnHand) {
            player.setGraphic('connect');
          }
        }

        player.controller.emit('playback.recordingSet', this);
      }
101673
def recording_settings(self):
        
        if self._recording_settings is None:
            self._recording_settings = RecordingSettingsList(self)
        return self._recording_settings
1254967
public static void recordStackedInvocation(Object on, String method, Object result, Object... params) {
		if (blockRecording.get())
			return;
		recordInvocation(false, true, false, on, method, result, params);
	}
917792
protected function proxy() {
        if (!$this->context) {
            $this->context = new RecordingContext($this->version, $this->solution['sid']);
        }

        return $this->context;
    }
1063389
function () {
    this._calls = []; // names/args of recorded calls
    this._initMethods();

    this._fillStyle = null;
    this._lineCap = null;
    this._lineDashOffset = null;
    this._lineJoin = null;
    this._lineWidth = null;
    this._strokeStyle = null;

    // Define properties here so that we can record each time they are set
    Object.defineProperties(this, {
        "fillStyle": {
            'get': function () {
                return this._fillStyle;
            },
            'set': function (style) {
                this._fillStyle = style;
                this.record('setFillStyle', [style]);
            }
        },
        'lineCap': {
            'get': function () {
                return this._lineCap;
            },
            'set': function (cap) {
                this._lineCap = cap;
                this.record('setLineCap', [cap]);
            }
        },
        'lineDashOffset': {
            'get': function () {
                return this._lineDashOffset;
            },
            'set': function (offset) {
                this._lineDashOffset = offset;
                this.record('setLineDashOffset', [offset]);
            }
        },
        'lineJoin': {
            'get': function () {
                return this._lineJoin;
            },
            'set': function (join) {
                this._lineJoin = join;
                this.record('setLineJoin', [join]);
            }
        },
        'lineWidth': {
            'get': function () {
                return this._lineWidth;
            },
            'set': function (width) {
                this._lineWidth = width;
                this.record('setLineWidth', [width]);
            }
        },
        'strokeStyle': {
            'get': function () {
                return this._strokeStyle;
            },
            'set': function (style) {
                this._strokeStyle = style;
                this.record('setStrokeStyle', [style]);
            }
        },
    });
}
70270
public void resumeRecording(){
        if (currentAudioState.get()==PAUSED_STATE){
            recordingStartTimeMillis=System.currentTimeMillis();
            currentAudioState.getAndSet(RECORDING_STATE);
            onTimeCompletedTimer=new Timer(true);
            onTimeCompletionTimerTask=new MaxTimeTimerTask();
            onTimeCompletedTimer.schedule(onTimeCompletionTimerTask,remainingMaxTimeInMillis);
        }
        else {
            Log.w(TAG,"Audio recording is not paused");
        }
    }
549824
protected void initTopLevelState(APMSpan topSpan, TraceRecorder recorder, ContextSampler sampler) {
        nodeBuilder = new NodeBuilder();
        traceContext = new TraceContext(topSpan, nodeBuilder, recorder, sampler);
    }
107827
function recordCanvasUsingRecordRTC(canvas) {
  var recorder = RecordRTC(canvas, {
      type: 'canvas',
      showMousePointer: true
  });

  recorder.startRecording();

  setTimeout(function() {
      recorder.stopRecording(function(url) {
          var blob = recorder.getBlob();
          console.log('blob', blob);

          var video = document.createElement('video');
          video.src = URL.createObjectURL(blob);
          video.setAttribute('style', 'height: 100%; position: absolute; top:0;');
          var body = document.querySelector('body');
          body.innerHTML = '';
          body.appendChild(video);
          video.controls = true;
          video.play();
      });
  }, 10 * 1000);
}
1333717
function onAudioInputCapture(evt) {
    try {
        if (evt && evt.data) {
            // Increase the debug counter for received data
            totalReceivedData += evt.data.length;

            // Push the data to the audio queue (array)
            audioDataQueue.push(evt.data);
        }
    }
    catch (ex) {
        alert("onAudioInputCapture ex: " + ex);
    }
}
1129532
def maybe_start_recording(tokens, index):
        """"""
        if _is_begin_quoted_type(tokens[index].type):
            string_type = _get_string_type_from_token(tokens[index].type)
            return _MultilineStringRecorder(index, string_type)

        return None
633826
def emitRecordMiddleDoubleClicked(self, item):
        
        # emit that the record has been double clicked
        if isinstance(item, XOrbRecordItem) and not self.signalsBlocked():
            self.recordMiddleDoubleClicked.emit(item.record())
670571
def makeSong(self):
        
        self.makeVisualSong()
        self.makeAudibleSong()
        if self.make_video:
            self.makeAnimation()
1233198
def record(self):
        # type: () -> bytes
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('ES record not yet initialized!')

        return b'ES' + struct.pack('=BBB', RRESRecord.length(), SU_ENTRY_VERSION, self.extension_sequence)
250503
public void analyzeFrames() {
        log.debug("Analyzing frames");
        if (audioSamplesToChunks != null) {
            // tag == sample
            int sample = 1;
            // position
            Long pos = null;
            //add the audio frames / samples / chunks		
            for (int i = 0; i < audioSamplesToChunks.size(); i++) {
                SampleToChunkBox.Entry record = audioSamplesToChunks.get(i);
                long firstChunk = record.getFirstChunk();
                long lastChunk = audioChunkOffsets.length;
                if (i < audioSamplesToChunks.size() - 1) {
                    SampleToChunkBox.Entry nextRecord = audioSamplesToChunks.get(i + 1);
                    lastChunk = nextRecord.getFirstChunk() - 1;
                }
                for (long chunk = firstChunk; chunk <= lastChunk; chunk++) {
                    long sampleCount = record.getSamplesPerChunk();
                    pos = audioChunkOffsets[(int) (chunk - 1)];
                    while (sampleCount > 0) {
                        //calculate ts
                        double ts = (audioSampleDuration * (sample - 1)) / audioTimeScale;
                        // sample size
                        int size = 0;
                        // if we have no samples, skip size check as its probably not aac
                        if (audioSamples.length > 0) {
                            //update sample size 
                            size = (int) audioSamples[sample - 1];
                            // skip empty AAC data which is 6 bytes long
                            log.trace("Audio sample - size: {} pos: {}", size, pos);
                            if (size == 6) {
                                try {
                                    // get current pos
                                    long position = dataSource.position();
                                    // jump to data position
                                    dataSource.position(pos);
                                    // create buffer to store bytes so we can check them
                                    ByteBuffer dst = ByteBuffer.allocate(6);
                                    // read the data
                                    dataSource.read(dst);
                                    // flip it
                                    dst.flip();
                                    // reset the position
                                    dataSource.position(position);
                                    byte[] tmp = dst.array();
                                    log.trace("Audio bytes: {} equal: {}", HexDump.byteArrayToHexString(tmp), Arrays.equals(MP4Reader.EMPTY_AAC, tmp));
                                    if (Arrays.equals(MP4Reader.EMPTY_AAC, tmp)) {
                                        log.trace("Skipping empty AAC data frame");
                                        // update counts
                                        pos += size;
                                        sampleCount--;
                                        sample++;
                                        // read next
                                        continue;
                                    }
                                } catch (IOException e) {
                                    log.warn("Exception during audio analysis", e);
                                }
                            }
                        }
                        // set audio sample size
                        size = (int) (size != 0 ? size : audioSampleSize);
                        //create a frame
                        MP4Frame frame = new MP4Frame();
                        frame.setOffset(pos);
                        frame.setSize(size);
                        frame.setTime(ts);
                        frame.setType(TYPE_AUDIO);
                        frames.add(frame);
                        //log.debug("Sample #{} {}", sample, frame);
                        // update counts
                        pos += size;
                        sampleCount--;
                        sample++;
                    }
                }
            }
        }
        //sort the frames
        Collections.sort(frames);
        log.debug("Frames count: {}", frames.size());
        //log.debug("Frames: {}", frames);
        //release some memory
        if (audioSamplesToChunks != null) {
            audioChunkOffsets = null;
            audioSamplesToChunks.clear();
            audioSamplesToChunks = null;
        }
    }
975867
static <K, V> void onResponse(ConsumerRecord<K, V> record, Span span) {
    setCommonTags(span);
    span.setTag("partition", record.partition());
    span.setTag("topic", record.topic());
    span.setTag("offset", record.offset());

  }
389885
public void startRecording() {
        if (mState != STATE.INITIALIZED) {
            Log.e(TAG, "startRecording called in invalid state. Ignoring");
            return;
        }
        synchronized (mReadyForFrameFence) {
            mFrameNum = 0;
            mRecording = true;
            mState = STATE.RECORDING;
        }
    }
458621
def emitCurrentRecordChanged(self, item):
        
        if self.signalsBlocked():
            return
        
        # emit that the record has been clicked
        if isinstance(item, XOrbRecordItem):
            self.currentRecordChanged.emit(item.record())
        else:
            self.currentRecordChanged.emit(None)