What's the correct AVRC rewind/fast-forward methodology?

[petkorazzi]

(Disclaimer: I'm an idiot-level coder who doesn't really know what he's doing - just bashing on my keyboard until stuff works.)

How exactly does one use the rewind() and fast_forward() functions?

I wasn't able to find any real documentation, examples, or use cases, and attempting to use them in the same way as the other AVRC functions like play() and next() has not been successful. Here's a basic example of what I've got going on:

// Short-press function
void click(Button2& btn) {
  if (btn == playBTN) {
    if (playbackstatus == 1) {
      a2dp_sink.pause();
    } else {
    a2dp_sink.play();
    }
  } else if (btn == stopBTN) {
    a2dp_sink.stop();
  } else if (btn == prevBTN) {
    a2dp_sink.previous();
  } else if (btn == nextBTN) {
    a2dp_sink.next();
  }
}

// Long-press function
void longClickDetected(Button2& btn) {
  if (playbackstatus == 1) {
    if (btn == prevBTN) {
      a2dp_sink.rewind();
    } else if (btn == nextBTN) {
      a2dp_sink.fast_forward();
    }
  }
}

// "On release of long-press" function.
void longClick(Button2& btn) {
  if (playbackstatus > 2) {
    a2dp_sink.play();
  }
}

The general idea is a typical 4-button control schema with play, stop, prev, and next buttons. Holding the prev or next button should rewind or fast-forward, and letting go should resume play. Admittedly this was done under the assumption that the rewind() and fast_forward() functions would be continuous - for example, calling the fast_forward() function would cause [whatever media] to fast forward until you tell it to stop. This seemed supported by esp_avrc_playback_stat_t playback having values for forward and reverse seeking (3 and 4 respectively).

I've confirmed that the long-press functionality works; it's not an issue with button code. To be sure, I also tried swapping one of the short-press button code sections with the rewind() and fast_forward() functions with no luck. These functions just don't seem to do anything at all.

I found this in BluetoothA2DPSink.cpp:

void BluetoothA2DPSink::execute_avrc_command(int cmd) {
  ESP_LOGD(BT_AV_TAG, "execute_avrc_command: %d", cmd);
  esp_err_t ok =
      esp_avrc_ct_send_passthrough_cmd(0, cmd, ESP_AVRC_PT_CMD_STATE_PRESSED);
  if (ok == ESP_OK) {
    delay_ms(100);
    ok = esp_avrc_ct_send_passthrough_cmd(0, cmd,
                                          ESP_AVRC_PT_CMD_STATE_RELEASED);
    if (ok == ESP_OK) {
      ESP_LOGD(BT_AV_TAG, "execute_avrc_command: %d -> OK", cmd);
    } else {
      ESP_LOGE(BT_AV_TAG,
               "execute_avrc_command ESP_AVRC_PT_CMD_STATE_RELEASED FAILED: %d",
               ok);
    }
  } else {
    ESP_LOGE(BT_AV_TAG,
             "execute_avrc_command ESP_AVRC_PT_CMD_STATE_PRESSED FAILED: %d",
             ok);
  }
}

void BluetoothA2DPSink::play() { execute_avrc_command(ESP_AVRC_PT_CMD_PLAY); }

void BluetoothA2DPSink::pause() { execute_avrc_command(ESP_AVRC_PT_CMD_PAUSE); }

void BluetoothA2DPSink::stop() { execute_avrc_command(ESP_AVRC_PT_CMD_STOP); }

void BluetoothA2DPSink::next() {
  execute_avrc_command(ESP_AVRC_PT_CMD_FORWARD);
}
void BluetoothA2DPSink::previous() {
  execute_avrc_command(ESP_AVRC_PT_CMD_BACKWARD);
}
void BluetoothA2DPSink::fast_forward() {
  execute_avrc_command(ESP_AVRC_PT_CMD_FAST_FORWARD);
}
void BluetoothA2DPSink::rewind() {
  execute_avrc_command(ESP_AVRC_PT_CMD_REWIND);
}

In particular, this bit:

esp_err_t ok =
      esp_avrc_ct_send_passthrough_cmd(0, cmd, ESP_AVRC_PT_CMD_STATE_PRESSED);
  if (ok == ESP_OK) {
    delay_ms(100);
    ok = esp_avrc_ct_send_passthrough_cmd(0, cmd,
                                          ESP_AVRC_PT_CMD_STATE_RELEASED);

Again, I'm an idiot and may be reading this entirely wrong - but is that basically saying that any AVRC function you call is only "pressing the button" for 100ms? If so, that may not matter for must functions but for seeking it definitely would I would think? But that also doesn't make sense - I may not know things but the person(s) who made this library do, and I don't see tons of "these functions don't work" issues or discussion in here.

So...this has got to be something I'm doing wrong. How do I do it right?

[harryberlin]

in my case the command let the track seek + or -10s once.
to get the track seeking (frwd or ffwd), i have to send the command every 500ms during hold down the button.
Swap back to play with play command is not needed.

[petkorazzi]

Swap back to play with play command is not needed.

Good to know, thank you!

in my case the command let the track seek + or -10s once.

For me it's doing literally nothing, and I don't know why. Are you using the functions the same way I am in my code example?

[pschatzmann]

For AVRC to work, you need to be connected with an A2DP Source
Your Application on the AVRC source needs to support the commend that you call.

I suggest to add some validation logic to your code to confirm that

• your logic is working by addeing some print commands
• check and display the connection status

[petkorazzi]

For AVRC to work, you need to be connected with an A2DP Source

Yep, and I am. Play/Pause/Stop/Prev/Next functions work fine, as does the actual source playback (I have the ESP32 connected to an external DAC via I2S).

Your Application on the AVRC source needs to support the commend that you call.

I've tried multiple applications and none work. Other devices (car stereo headunit, various Bluetooth headsets, etc.) are able to use rewind/fast-forward AVRC functions with these applications just fine. I'll try a few more just to be sure, though.

I suggest to add some validation logic to your code to confirm that your logic is working by addeing some print commands

Yep, I've done that. The functions are definitely being called. I've also done the same with the playstatus callback and the seek statuses are never returned during this either.

check and display the connection status

I've done that too (I'm using the onboard LED to display connection status for the time being).

I'll throw together a new test sketch that's a pure AVRC feature test and uses serial inputs as commands instead of buttons just in case there's something with the Button2 library that's borking things, but with things as they are I'm very confused.