You can borrow missing (to count of 8) bytes from adjacent value and then throw them away with post-processing, applying a mask. Looks like it's faster to stay "numeric" at all stages if possible. The "unpack-pad-pack-unpack", (tybalt89's solution) is somewhere in the middle in terms of performance. Not that you said speed is the goal, but anyway:

use strict;
use warnings;
no warnings 'portable';
use Benchmark 'cmpthese';

my $bytes_per_value = 5;
my $count = 1_000;

my $value = 0xf_dead_beef_4;
my $bin_value = substr (pack ('Q', $value), 0, $bytes_per_value);
my $buffer = $bin_value x $count;

my $fmt = sprintf "(b%d)*", $bytes_per_value << 3;

my $pad_len = 8 - $bytes_per_value;
my $mask = ~ 0 >> $pad_len * 8;

cmpthese -1, {
    strings => sub {
        my @values = map { oct '0b'.reverse ($_)} 
            unpack ($fmt, $buffer);
        return \@values;
    },
    numbers => sub {
        my @values = unpack "(QX$pad_len)$count", 
            $buffer . "\0" x $pad_len;
        $_ &= $mask for @values;
        return \@values;
    },
};        

__END__

           Rate strings numbers
strings  2386/s      --    -77%
numbers 10274/s    331%      --
[download]

I had to explicitly include a count in template: "(QX$pad_len)$count", instead of simply "(QX$pad_len)*", because otherwise @values array would result in a very puzzling length of 2501 items instead of 1000 i.e. $count.

I suspect there's special code somewhere to prevent ((un?)documented(?) case of) endless loops with '(CX)*' or '(vX2)*' or similar, but still:

say for unpack '(VX2)*', "\1\1\1\1";    # why 2 items?
say for unpack '(VX3)*', "\1\1\1\1";

'X' outside of string in unpack         # how's that?
[download]

and why 2501 items with '(QX3)*' template to begin with?

I have not been able to come up with a way to do it in a single unpack, but if I post my solution maybe someone will come up with something better:

# Arguments are datum length (5, 6, 7, or 8) and stream data (whose
# length must be a multiple of the datum length)
sub unpack_stream {
    my ( $length, $stream ) = @_;
    $length ||= 5;
    $length >= 5
    and $length <= 8
    or die "Length $length must be between 5 and 8 inclusive\n";
    my $pad = pack 'C*', ( 0 ) x ( 8 - $length );
    return map { unpack 'Q<', "$_$pad" } unpack "(a$length)*", $stream
+;
}
[download]

Maybe unpack can't but pack can :)

try:

return unpack '(Q<)*', pack '(a8)*', unpack "(a$length)*", $stream;
[download]

And you no longer need $pad or the map.

semi-tested :)

See? I knew someone would come up with something cleaner. Thanks.

I understand the OP to have requested that it be done in a single unpack, but I'm convinced that is not possible -- a challenge for someone to come along and prove me wrong. And that is how knowledge grows.

I don't clearly understand your problem, but it reminds me of the recent question Split any number into string of 8-bit hex values (=1 byte). Perhaps it may give you some insight concerning a solution.

One important lesson to take away from that post is the importance of clearly stating a problem. :)

se strict;
use warnings;
no warnings 'portable';
use Benchmark 'cmpthese';

my $bytes_per_value = 5;
my $count = 1_000;

my $value = 0xf_dead_beef_4;
my $bin_value = substr (pack ('Q', $value), 0, $bytes_per_value);
my $buffer = $bin_value x $count;

my $fmt = sprintf "(b%d)*", $bytes_per_value << 3;

my $pad_len = 8 - $bytes_per_value;
my $mask = ~ 0 >> $pad_len * 8;
my $pad = "\0" x $pad_len;
my @fmts = ('(Q<)', '(Q<X)', '(Q<X2)', '(Q<X3)');
my $fmt2 = $fmts[$pad_len] . sprintf ("%d", $count);

cmpthese -1, {
    strings => sub {
        my @values = map { oct '0b'.reverse ($_)} unpack ($fmt, $buffe
+r);
        return \@values;
    },
    map_unpack => sub {
        my @values =  map { unpack 'Q<', "$_$pad" } unpack "(a$bytes_p
+er_value)*", $buffer;
        return \@values;
    },
    unpack_pack_unpack => sub {
        my @values = unpack '(Q<)*', pack '(a8)*', unpack "(a$bytes_pe
+r_value)*", $buffer;
    },
    numbers_map => sub {
        my @values = unpack "(QX$pad_len)$count", $buffer.$pad;
        map { $_ &= $mask } @values;
        return \@values;
    },
    numbers_for => sub {
        my @values = unpack $fmt2, $buffer.$pad;
        if ($pad_len) {
             $_ &= $mask for @values;
        }
        return \@values;
    },
};
__END__
[download]

                     Rate strings map_unpack unpack_pack_unpack number
+s_map numbers_for
strings            1707/s      --       -28%               -47%       
+ -69%        -77%
map_unpack         2386/s     40%         --               -26%       
+ -56%        -68%
unpack_pack_unpack 3242/s     90%        36%                 --       
+ -41%        -57%
numbers_map        5462/s    220%       129%                68%       
+   --        -28%
numbers_for        7538/s    342%       216%               133%       
+  38%          --
[download]