YouTube playlist steganography: hide secret messages inside YouTube playlists
Style

In any significant project, especially one that you are sharing through GitHub, it is important to write docstrings for each function.  You haven't written any.

It is implied by the PEP 8 official style guide that functions should be named using lower_case_with_underscores and constants should be named using UPPER_CASE_WITH_UNDERSCORES.  I would recommend renaming BITARRAY → BIT_ARRAY and getsum() → get_sum(), because pythonisnotgermanorfinnish.

Implementation

Whenever you build a list by starting with an empty list and appending to it in a loop, you'll almost certainly want to write a list comprehension or a generator expression instead.  That way, you describe the result "all at once" using a single statement.

from string import digits, ascii_uppercase, ascii_lowercase

INIT_CHARS = '-' + digits + ascii_uppercase + '_' + ascii_lowercase
FINAL_CHARS = '048AEIMQUYcgkosw'
BIT_ARRAY = sum(([tuple((a, b)) for a in INIT_CHARS] for b in FINAL_CHARS), [])


The sum() function above is used to concatenate lists.  That expression is a bit nasty.  You can write it better using itertools.product(), which is exactly what we need:

from itertools import product
from string import digits, ascii_uppercase, ascii_lowercase

INIT_CHARS = '-' + digits + ascii_uppercase + '_' + ascii_lowercase
FINAL_CHARS = '048AEIMQUYcgkosw'
BIT_ARRAY = list(product(INIT_CHARS, FINAL_CHARS))


Note, however, that it would be better not to define your BITARRAY at all, if your only goal is to find the index of a particular pair of characters.  Instead of BITARRAY.index(…), it would be more efficient to do a little arithmetic:

def numeric_value(init_char, final_char):
    """
    Given character init_char (one of the characters [-0-9A-Z_a-z]) and
    character final_char (one of the characters [048AEIMQUYcgkosw]),
    deterministically produce a numeric value from 0 to 1023, inclusive.
    """
    return INIT_CHARS.index(init_char) * len(FINAL_CHARS) + \
           FINAL_CHARS.index(final_char)


Based on similar principles, I would write this function:

def get_sum(video_ids):
    """
    Compute a tuple of numbers for the given YouTube video IDs.

    The videos IDs are taken two at a time.  From each pair, the initial
    character of the first ID and the final character of the second ID are
    taken.  Those two characters are mapped a numeric value between 0 and 1023.

    If there are an odd number of video IDs, the last one is ignored.
    """
    return tuple(
        numeric_value(a[0], b[-1]) for a, b in zip(*[iter(video_ids)] * 2)
    )


The zip(*[iter(video_ids)] * 2) expression above is a slick way to split the video_ids into pairs.  It comes from the grouper() example in the itertools recipes.

Note that your original getsum(addrlist) function is actually equivalent1 to

def getsum(addrlist):
    return [get_sum(playlist) for playlist in addrlist]


I recommend splitting the work this way instead, so that you don't end up with an excessively nested list comprehension.



1 Well, it's not exactly equivalent, in that your BITARRAY lookup silently ignores pairs of characters that do not conform to the ([-0-9A-Z_a-z], [048AEIMQUYcgkosw]) scheme, whereas numeric_value(…) would raise a ValueError.