function base64ToArrayBuffer(base64) {
    var binaryString = atob(base64);
    var bytes = new Uint8Array(binaryString.length);
    for (var i = 0; i < binaryString.length; i++) {
        bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes.buffer;
}

You can use XMLHttpRequest to do the dirty work for you:

var url = document.createElement("canvas").toDataURL(); // some data-uri

var xhr = new XMLHttpRequest();
xhr.open("GET", url);
xhr.responseType = "arraybuffer";
xhr.onload = function() {
  // result = ArrayBuffer, from here assign a view to it
  if (xhr.status === 200) console.log(new Uint8Array(xhr.response));
};
xhr.send();

It's a little more code than using atob() but all conversion happens internally. It's async too which can help with larger Data-URIs.

In newer browsers (which supports it) you can instead use fetch():

// note: atm not all browsers support these features.
fetch(document.createElement("canvas").toDataURL())  // pass in some data-uri
  .then(function(response) {return response.arrayBuffer()})
  .then(function(buffer) {
    console.log(new Uint8Array(buffer));
  });

function base64ToArrayBuffer(base64) {
    var binaryString = atob(base64);
    var bytes = new Uint8Array(binaryString.length);
    for (var i = 0; i < binaryString.length; i++) {
        bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes.buffer;
}

function _arrayBufferToBase64( buffer ) {
    var binary = '';
    var bytes = new Uint8Array( buffer );
    var len = bytes.byteLength;
    for (var i = 0; i < len; i++) {
        binary += String.fromCharCode( bytes[ i ] );
    }
    return window.btoa( binary );
}

but, non-native implementations are faster e.g. https://gist.github.com/958841 see http://jsperf.com/encoding-xhr-image-data/6

jsPerf.com is jsPerf.app now: https://jsperf.app/encoding-xhr-image-data/51

Updated benchmarks: https://jsben.ch/wnaZC

The problem seem originated from this line:

byte[] picture = Convert.FromBase64String(base64img);

If the base64img contains some header like data:image/png;base64, then Convert.FromBase64String() fails because the string is not fully formatted in Base64 format. Consider using string.Split() before converting from string parameter to remove corresponding Base64 header:

[HttpPost]
public ActionResult LoadImage(Car car, string base64img)
{
    // split the header and content, separated by comma
    var base64arr = base64img.Split(',');
    byte[] picture = Convert.FromBase64String(base64arr[1]);

    // do something with the image

    return View();
}

If the content string contains characters other than ASCII or trailing padding ones, you should remove them like this:

string base64str = base64arr[1];
string processed = base64str.Replace('_', '/').Replace('-', '+');

switch (base64str.Length % 4) 
{
    case 2: 
       processed += "=="; 
       break;
    case 3: 
       processed += "="; 
       break;
}

byte[] picture = Convert.FromBase64String(processed);

Also consider using FormData object when passing image formatted with Base64 string:

$('#modalWindow').on('click', '#send', function () {
    var file = $('#autoPicture').attr('src');

    // note: if you send other form data, use 'serializeArray()' or 'serialize()'

    var formData = new FormData();
    // append other form contents here
    formData.append("base64img", file);

    $.ajax({
        type: "POST",
        url: "/Home/LoadImage",
        data: formData,
        success: function (data) {
            alert('Привет');
        },
        error: function (error) {
            alert(error.responseText);
        }
    });
});

Note:

The equals sign like = or == at the end of Base64 encoded string serves as trailing padding characters and not all Base64 encoded strings ended with them. You can see the reason behind padding here.

function base64ToArrayBuffer(base64) {
    var binaryString = atob(base64);
    var bytes = new Uint8Array(binaryString.length);
    for (var i = 0; i < binaryString.length; i++) {
        bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes.buffer;
}